﻿// Copyright (c) ServiceStack, Inc. All Rights Reserved.
// License: https://raw.github.com/ServiceStack/ServiceStack/master/license.txt

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using ServiceStack.Extensions;
using ServiceStack.Script;
using ServiceStack.Text;

namespace ServiceStack
{
    public class TextNode
    {
        public TextNode()
        {
            Children = new List<TextNode>();
        }

        public string Text { get; set; }

        public List<TextNode> Children { get; set; }
    }

    public static class StringUtils
    {
        public static List<Command> ParseCommands(this string commandsString)
        {
            return commandsString.AsMemory().ParseCommands(',');
        }
        
        public static List<Command> ParseCommands(this ReadOnlyMemory<char> commandsString, 
            char separator = ',')
        {
            var to = new List<Command>();
            List<ReadOnlyMemory<char>> args = null;
            var pos = 0;

            if (commandsString.IsNullOrEmpty())
                return to;

            var inDoubleQuotes = false;
            var inSingleQuotes = false;
            var inBackTickQuotes = false;
            var inPrimeQuotes = false;
            var inBrackets = false;

            var endBlockPos = commandsString.Length;
            var cmd = new Command();
            var segmentStartPos = 0;

            try
            {
                for (var i = 0; i < commandsString.Length; i++)
                {
                    var c = commandsString.Span[i];
                    if (c.IsWhiteSpace())
                        continue;

                    if (inDoubleQuotes)
                    {
                        if (c == '"')
                            inDoubleQuotes = false;
                        continue;
                    }
                    if (inSingleQuotes)
                    {
                        if (c == '\'')
                            inSingleQuotes = false;
                        continue;
                    }
                    if (inBackTickQuotes)
                    {
                        if (c == '`')
                            inBackTickQuotes = false;
                        continue;
                    }
                    if (inPrimeQuotes)
                    {
                        if (c == '′')
                            inPrimeQuotes = false;
                        continue;
                    }
                    switch (c)
                    {
                        case '"':
                            inDoubleQuotes = true;
                            continue;
                        case '\'':
                            inSingleQuotes = true;
                            continue;
                        case '`':
                            inBackTickQuotes = true;
                            continue;
                        case '′':
                            inPrimeQuotes = true;
                            continue;
                    }

                    if (c == '(')
                    {
                        inBrackets = true;
                        cmd.Name = commandsString.Slice(pos, i - pos).Trim().ToString();
                        pos = i + 1;

                        var literal = commandsString.Slice(pos);
                        var literalRemaining = ParseArguments(literal, out args);
                        cmd.Args = args;
                        var endPos = literal.Length - literalRemaining.Length;
                        
                        i += endPos;
                        pos = i + 1;
                        continue;
                    }
                    if (c == ')')
                    {
                        inBrackets = false;
                        pos = i + 1;

                        pos = cmd.IndexOfMethodEnd(commandsString, pos);
                        continue;
                    }

                    if (inBrackets && c == ',')
                    {
                        var arg = commandsString.Slice(pos, i - pos).Trim();
                        cmd.Args.Add(arg);
                        pos = i + 1;
                    }
                    else if (c == separator)
                    {
                        if (string.IsNullOrEmpty(cmd.Name))
                            cmd.Name = commandsString.Slice(pos, i - pos).Trim().ToString();
                        else
                            cmd.Suffix = commandsString.Slice(pos - cmd.Suffix.Length, i - pos + cmd.Suffix.Length);

                        cmd.Original = commandsString.Slice(segmentStartPos, i - segmentStartPos).Trim();

                        to.Add(cmd);
                        cmd = new Command();
                        segmentStartPos = pos = i + 1;
                    }
                }

                var remaining = commandsString.Slice(pos, endBlockPos - pos);
                if (!remaining.Trim().IsNullOrEmpty())
                {
                    pos += remaining.Length;
                    cmd.Name = remaining.Trim().ToString();
                }

                if (!cmd.Name.IsNullOrEmpty())
                {
                    cmd.Original = commandsString.Slice(segmentStartPos, commandsString.Length - segmentStartPos).Trim();
                    to.Add(cmd);
                }
            }
            catch (Exception e)
            {
                throw new Exception($"Illegal syntax near '{commandsString.SafeSlice(pos - 10, 50)}...'", e);
            }

            return to;
        }
        
        // ( {args} , {args} )
        //   ^
        public static ReadOnlyMemory<char> ParseArguments(ReadOnlyMemory<char> argsString, out List<ReadOnlyMemory<char>> args)
        {
            var to = new List<ReadOnlyMemory<char>>();

            var inDoubleQuotes = false;
            var inSingleQuotes = false;
            var inBackTickQuotes = false;
            var inPrimeQuotes = false;
            var inBrackets = 0;
            var inParens = 0;
            var inBraces = 0;
            var lastPos = 0;

            for (var i = 0; i < argsString.Length; i++)
            {
                var c = argsString.Span[i];
                if (inDoubleQuotes)
                {
                    if (c == '"')
                        inDoubleQuotes = false;
                    continue;
                }
                if (inSingleQuotes)
                {
                    if (c == '\'')
                        inSingleQuotes = false;
                    continue;
                }
                if (inBackTickQuotes)
                {
                    if (c == '`')
                        inBackTickQuotes = false;
                    continue;
                }
                if (inPrimeQuotes)
                {
                    if (c == '′')
                        inPrimeQuotes = false;
                    continue;
                }
                if (inBrackets > 0)
                {
                    if (c == '[')
                        ++inBrackets;
                    else if (c == ']')
                        --inBrackets;
                    continue;
                }
                if (inBraces > 0)
                {
                    if (c == '{')
                        ++inBraces;
                    else if (c == '}')
                        --inBraces;
                    continue;
                }
                if (inParens > 0)
                {
                    if (c == '(')
                        ++inParens;
                    else if (c == ')')
                        --inParens;
                    continue;
                }

                switch (c)
                {
                    case '"':
                        inDoubleQuotes = true;
                        continue;
                    case '\'':
                        inSingleQuotes = true;
                        continue;
                    case '`':
                        inBackTickQuotes = true;
                        continue;
                    case '′':
                        inPrimeQuotes = true;
                        continue;
                    case '[':
                        inBrackets++;
                        continue;
                    case '{':
                        inBraces++;
                        continue;
                    case '(':
                        inParens++;
                        continue;
                    case ',':
                    {
                        var arg = argsString.Slice(lastPos, i - lastPos).Trim();
                        to.Add(arg);
                        lastPos = i + 1;
                        continue;
                    }
                    case ')':
                    {
                        var arg = argsString.Slice(lastPos, i - lastPos).Trim();
                        if (!arg.IsNullOrEmpty())
                        {
                            to.Add(arg);
                        }

                        args = to;
                        return argsString.Advance(i);
                    }
                }
            }
            
            args = to;
            return TypeConstants.EmptyStringMemory;
        }

        /// <summary>
        /// Multiple string replacements
        /// </summary>
        /// <param name="replaceStringsPairs">Even number of old and new value pairs</param>
        public static string ReplacePairs(string str, string[] replaceStringsPairs)
        {
            if (replaceStringsPairs.Length < 2 || replaceStringsPairs.Length % 2 != 0)
                throw new ArgumentException("Replacement pairs must be an even number of old and new value pairs", nameof(replaceStringsPairs));
            
            for (var i = 0; i < replaceStringsPairs.Length; i+=2)
            {
                str = str.Replace(replaceStringsPairs[i], replaceStringsPairs[i + 1]);
            }
            return str;
        }
        
        /// <summary>
        /// Replace string contents outside of string quotes 
        /// </summary>
        public static string ReplaceOutsideOfQuotes(this string str, params string[] replaceStringsPairs)
        {
            var inDoubleQuotes = false;
            var inSingleQuotes = false;
            var inBackTickQuotes = false;
            var inPrimeQuotes = false;
            var quoteStartPos = 0;
            var chunkLastPos = 0;

            var sb = StringBuilderCache.Allocate();

            for (var i = 0; i < str.Length; i++)
            {
                var c = str[i];
                if (i > 0 && c == '\\')
                {
                    switch (str[i-1]) 
                    {
                        case '"':
                        case '\'':
                        case '`':
                        case '′':
                            continue;
                    }
                }

                if (inDoubleQuotes)
                {
                    if (c == '"')
                    {
                        sb.Append(str.Substring(quoteStartPos, (chunkLastPos = i) - quoteStartPos));
                        inDoubleQuotes = false;
                    }
                    continue;
                }
                if (inSingleQuotes)
                {
                    if (c == '\'')
                    {
                        sb.Append(str.Substring(quoteStartPos, (chunkLastPos = i) - quoteStartPos));
                        inSingleQuotes = false;
                    }
                    continue;
                }
                if (inBackTickQuotes)
                {
                    if (c == '`')
                    {
                        sb.Append(str.Substring(quoteStartPos, (chunkLastPos = i) - quoteStartPos));
                        inBackTickQuotes = false;
                    }
                    continue;
                }
                if (inPrimeQuotes)
                {
                    if (c == '′')
                    {
                        sb.Append(str.Substring(quoteStartPos, (chunkLastPos = i) - quoteStartPos));
                        inPrimeQuotes = false;
                    }
                    continue;
                }
                
                switch (c) 
                {
                    case '"':
                    case '\'':
                    case '`':
                    case '′':
                        var prevChunk = str.Substring(chunkLastPos, i-chunkLastPos);
                        sb.Append(ReplacePairs(prevChunk, replaceStringsPairs));
                        chunkLastPos = i;
                        quoteStartPos = i;
                        switch (c)
                        {
                            case '"':
                                inDoubleQuotes = true;
                                continue;
                            case '\'':
                                inSingleQuotes = true;
                                continue;
                            case '`':
                                inBackTickQuotes = true;
                                continue;
                            case '′':
                                inPrimeQuotes = true;
                                continue;
                        }
                        continue;
                }
            }

            var lastChunk = str.Substring(chunkLastPos);
            sb.Append(ReplacePairs(lastChunk, replaceStringsPairs));

            var ret = StringBuilderCache.ReturnAndFree(sb);
            return ret;
        }

        /// <summary>
        /// Protect against XSS by cleaning non-standard User Input
        /// </summary>
        public static string SafeInput(this string text)
        {
            return string.IsNullOrEmpty(text)
                ? text
                : SafeInputRegEx.Replace(text, "");
        }

        public static readonly Dictionary<char, string> EscapedCharMap = new Dictionary<char, string> {
            // {'\'', @"\'"},
            {'\"', "\\\""},
            {'\\', @"\\"},
            {'\0', @"\0"},
            {'\a', @"\a"},
            {'\b', @"\b"},
            {'\f', @"\f"},
            {'\n', @"\n"},
            {'\r', @"\r"},
            {'\t', @"\t"},
            {'\v', @"\v"},
        };

        public static string ToEscapedString(this string input)
        {
            var sb = new StringBuilder(input.Length + 2);
            sb.Append('"');
            foreach (var c in input)
            {
                if (EscapedCharMap.TryGetValue(c, out var escapedChar))
                {
                    sb.Append(escapedChar);
                }
                else
                {
                    if (char.GetUnicodeCategory(c) != UnicodeCategory.Control)
                    {
                        sb.Append(c);
                    }
                    else
                    {
                        sb.Append(@"\u");
                        sb.Append(((ushort) c).ToString("x4"));
                    }
                }
            }
            sb.Append('"');
            return sb.ToString();
        }

        public static string SnakeCaseToPascalCase(string snakeCase)
        {
            if (string.IsNullOrEmpty(snakeCase))
                return snakeCase;
            
            var safeVarName = snakeCase.SafeVarName();
            if (safeVarName.IndexOf('_') >= 0)
            {
                var parts = safeVarName.Split('_').Where(x => !string.IsNullOrEmpty(x));
                var pascalName = "";
                foreach (var part in parts)
                {
                    pascalName += char.ToUpper(part[0]) + part.Substring(1);
                }
                return pascalName;
            }
            return char.IsLower(safeVarName[0])
                ? char.ToUpper(safeVarName[0]) + safeVarName.Substring(1)
                : safeVarName;
        }

        public static string RemoveSuffix(string name, string suffix) => name == null ? null :
            name.EndsWith(suffix)
                ? name.Substring(0, name.Length - suffix.Length)
                : name;

        static readonly Regex StripHtmlUnicodeRegEx =
            new Regex(@"&(#)?([xX])?([^ \f\n\r\t\v;]+);", RegexOptions.Compiled);

        static readonly Regex SafeInputRegEx = new Regex(@"[^\w\s\.,@-\\+\\/]", RegexOptions.Compiled);

        public static string HtmlEncodeLite(this string html)
        {
            return html.Replace("<", "&lt;").Replace(">", "&gt;");
        }

        public static string HtmlEncode(this string html)
        {
            return System.Net.WebUtility.HtmlEncode(html).Replace("′", "&prime;");
        }

        public static string HtmlDecode(this string html)
        {
            return System.Net.WebUtility.HtmlDecode(html);
        }

        public static string ConvertHtmlCodes(this string html)
        {
            return StripHtmlUnicodeRegEx.Replace(html, ConvertHtmlCodeToCharacter);
        }

        static string ConvertHtmlCodeToCharacter(Match match)
        {
            // http://www.w3.org/TR/html5/syntax.html#character-references
            // match.Groups[0] is the entire match, the sub groups start at index one
            if (!match.Groups[1].Success)
            {
                if (HtmlCharacterCodes.TryGetValue(match.Value, out var convertedValue))
                {
                    return convertedValue;
                }
                return match.Value; // ambiguous ampersand
            }
            string decimalString = match.Groups[3].Value;
            ushort decimalValue;
            if (match.Groups[2].Success)
            {
                bool parseWasSuccessful = ushort.TryParse(decimalString, NumberStyles.HexNumber,
                    CultureInfo.InvariantCulture, out decimalValue);
                if (!parseWasSuccessful)
                {
                    return match.Value; // ambiguous ampersand
                }
            }
            else
            {
                bool parseWasSuccessful = ushort.TryParse(decimalString, out decimalValue);
                if (!parseWasSuccessful)
                {
                    return match.Value; // ambiguous ampersand
                }
            }

            return Convert.ToString((char) decimalValue, CultureInfo.InvariantCulture);
        }

        public static string ToChar(this int codePoint)
        {
            return Convert.ToString(Convert.ToChar(codePoint), CultureInfo.InvariantCulture);
        }

        public static List<string> SplitGenericArgs(string argList)
        {
            var to = new List<string>();
            if (string.IsNullOrEmpty(argList))
                return to;

            var lastPos = 0;
            var blockCount = 0;
            for (var i = 0; i < argList.Length; i++)
            {
                var argChar = argList[i];
                switch (argChar)
                {
                    case ',':
                        if (blockCount == 0)
                        {
                            var arg = argList.Substring(lastPos, i - lastPos);
                            to.Add(arg);
                            lastPos = i + 1;
                        }
                        break;
                    case '<':
                        blockCount++;
                        break;
                    case '>':
                        blockCount--;
                        break;
                }
            }

            if (lastPos > 0)
            {
                var arg = argList.Substring(lastPos);
                to.Add(arg);
            }
            else
            {
                to.Add(argList);
            }

            return to;
        }

        static char[] blockChars = new[] { '<', '>' };
        public static TextNode ParseTypeIntoNodes(this string typeDef)
        {
            if (string.IsNullOrEmpty(typeDef))
                return null;

            var node = new TextNode();
            var lastBlockPos = typeDef.IndexOf('<');

            if (lastBlockPos >= 0)
            {
                node.Text = typeDef.Substring(0, lastBlockPos).Trim();

                var blockStartingPos = new Stack<int>();
                blockStartingPos.Push(lastBlockPos);

                while (lastBlockPos != -1 || blockStartingPos.Count == 0)
                {
                    var nextPos = typeDef.IndexOfAny(blockChars, lastBlockPos + 1);
                    if (nextPos == -1)
                        break;

                    var blockChar = typeDef.Substring(nextPos, 1);

                    if (blockChar == "<")
                    {
                        blockStartingPos.Push(nextPos);
                    }
                    else
                    {
                        var startPos = blockStartingPos.Pop();
                        if (blockStartingPos.Count == 0)
                        {
                            var endPos = nextPos;
                            var childBlock = typeDef.Substring(startPos + 1, endPos - startPos - 1);

                            var args = SplitGenericArgs(childBlock);
                            foreach (var arg in args)
                            {
                                if (arg.IndexOfAny(blockChars) >= 0)
                                {
                                    var childNode = ParseTypeIntoNodes(arg);
                                    if (childNode != null)
                                    {
                                        node.Children.Add(childNode);
                                    }
                                }
                                else
                                {
                                    node.Children.Add(new TextNode { Text = arg.Trim() });
                                }
                            }

                        }
                    }

                    lastBlockPos = nextPos;
                }
            }
            else
            {
                node.Text = typeDef.Trim();
            }

            return node;
        }
        
        
        // http://www.w3.org/TR/html5/entities.json
        // TODO: conditional compilation for NET45 that uses ReadOnlyDictionary
        public static readonly IDictionary<string, string> HtmlCharacterCodes = new SortedDictionary<string, string> {
            {@"&Aacute;", 193.ToChar()},
            {@"&aacute;", 225.ToChar()},
            {@"&Abreve;", 258.ToChar()},
            {@"&abreve;", 259.ToChar()},
            {@"&ac;", 8766.ToChar()},
            {@"&acd;", 8767.ToChar()},
            {@"&acE;", 8766.ToChar()},
            {@"&Acirc;", 194.ToChar()},
            {@"&acirc;", 226.ToChar()},
            {@"&acute;", 180.ToChar()},
            {@"&Acy;", 1040.ToChar()},
            {@"&acy;", 1072.ToChar()},
            {@"&AElig;", 198.ToChar()},
            {@"&aelig;", 230.ToChar()},
            {@"&af;", 8289.ToChar()},
//{ @"&Afr;", 120068.ToChar() },
//{ @"&afr;", 120094.ToChar() },
            {@"&Agrave;", 192.ToChar()},
            {@"&agrave;", 224.ToChar()},
            {@"&alefsym;", 8501.ToChar()},
            {@"&aleph;", 8501.ToChar()},
            {@"&Alpha;", 913.ToChar()},
            {@"&alpha;", 945.ToChar()},
            {@"&Amacr;", 256.ToChar()},
            {@"&amacr;", 257.ToChar()},
            {@"&amalg;", 10815.ToChar()},
            {@"&AMP;", 38.ToChar()},
            {@"&amp;", 38.ToChar()},
            {@"&And;", 10835.ToChar()},
            {@"&and;", 8743.ToChar()},
            {@"&andand;", 10837.ToChar()},
            {@"&andd;", 10844.ToChar()},
            {@"&andslope;", 10840.ToChar()},
            {@"&andv;", 10842.ToChar()},
            {@"&ang;", 8736.ToChar()},
            {@"&ange;", 10660.ToChar()},
            {@"&angle;", 8736.ToChar()},
            {@"&angmsd;", 8737.ToChar()},
            {@"&angmsdaa;", 10664.ToChar()},
            {@"&angmsdab;", 10665.ToChar()},
            {@"&angmsdac;", 10666.ToChar()},
            {@"&angmsdad;", 10667.ToChar()},
            {@"&angmsdae;", 10668.ToChar()},
            {@"&angmsdaf;", 10669.ToChar()},
            {@"&angmsdag;", 10670.ToChar()},
            {@"&angmsdah;", 10671.ToChar()},
            {@"&angrt;", 8735.ToChar()},
            {@"&angrtvb;", 8894.ToChar()},
            {@"&angrtvbd;", 10653.ToChar()},
            {@"&angsph;", 8738.ToChar()},
            {@"&angst;", 197.ToChar()},
            {@"&angzarr;", 9084.ToChar()},
            {@"&Aogon;", 260.ToChar()},
            {@"&aogon;", 261.ToChar()},
//{ @"&Aopf;", 120120.ToChar() },
//{ @"&aopf;", 120146.ToChar() },
            {@"&ap;", 8776.ToChar()},
            {@"&apacir;", 10863.ToChar()},
            {@"&apE;", 10864.ToChar()},
            {@"&ape;", 8778.ToChar()},
            {@"&apid;", 8779.ToChar()},
            {@"&apos;", 39.ToChar()},
            {@"&ApplyFunction;", 8289.ToChar()},
            {@"&approx;", 8776.ToChar()},
            {@"&approxeq;", 8778.ToChar()},
            {@"&Aring;", 197.ToChar()},
            {@"&aring;", 229.ToChar()},
//{ @"&Ascr;", 119964.ToChar() },
//{ @"&ascr;", 119990.ToChar() },
            {@"&Assign;", 8788.ToChar()},
            {@"&ast;", 42.ToChar()},
            {@"&asymp;", 8776.ToChar()},
            {@"&asympeq;", 8781.ToChar()},
            {@"&Atilde;", 195.ToChar()},
            {@"&atilde;", 227.ToChar()},
            {@"&Auml;", 196.ToChar()},
            {@"&auml;", 228.ToChar()},
            {@"&awconint;", 8755.ToChar()},
            {@"&awint;", 10769.ToChar()},
            {@"&backcong;", 8780.ToChar()},
            {@"&backepsilon;", 1014.ToChar()},
            {@"&backprime;", 8245.ToChar()},
            {@"&backsim;", 8765.ToChar()},
            {@"&backsimeq;", 8909.ToChar()},
            {@"&Backslash;", 8726.ToChar()},
            {@"&Barv;", 10983.ToChar()},
            {@"&barvee;", 8893.ToChar()},
            {@"&Barwed;", 8966.ToChar()},
            {@"&barwed;", 8965.ToChar()},
            {@"&barwedge;", 8965.ToChar()},
            {@"&bbrk;", 9141.ToChar()},
            {@"&bbrktbrk;", 9142.ToChar()},
            {@"&bcong;", 8780.ToChar()},
            {@"&Bcy;", 1041.ToChar()},
            {@"&bcy;", 1073.ToChar()},
            {@"&bdquo;", 8222.ToChar()},
            {@"&becaus;", 8757.ToChar()},
            {@"&Because;", 8757.ToChar()},
            {@"&because;", 8757.ToChar()},
            {@"&bemptyv;", 10672.ToChar()},
            {@"&bepsi;", 1014.ToChar()},
            {@"&bernou;", 8492.ToChar()},
            {@"&Bernoullis;", 8492.ToChar()},
            {@"&Beta;", 914.ToChar()},
            {@"&beta;", 946.ToChar()},
            {@"&beth;", 8502.ToChar()},
            {@"&between;", 8812.ToChar()},
//{ @"&Bfr;", 120069.ToChar() },
//{ @"&bfr;", 120095.ToChar() },
            {@"&bigcap;", 8898.ToChar()},
            {@"&bigcirc;", 9711.ToChar()},
            {@"&bigcup;", 8899.ToChar()},
            {@"&bigodot;", 10752.ToChar()},
            {@"&bigoplus;", 10753.ToChar()},
            {@"&bigotimes;", 10754.ToChar()},
            {@"&bigsqcup;", 10758.ToChar()},
            {@"&bigstar;", 9733.ToChar()},
            {@"&bigtriangledown;", 9661.ToChar()},
            {@"&bigtriangleup;", 9651.ToChar()},
            {@"&biguplus;", 10756.ToChar()},
            {@"&bigvee;", 8897.ToChar()},
            {@"&bigwedge;", 8896.ToChar()},
            {@"&bkarow;", 10509.ToChar()},
            {@"&blacklozenge;", 10731.ToChar()},
            {@"&blacksquare;", 9642.ToChar()},
            {@"&blacktriangle;", 9652.ToChar()},
            {@"&blacktriangledown;", 9662.ToChar()},
            {@"&blacktriangleleft;", 9666.ToChar()},
            {@"&blacktriangleright;", 9656.ToChar()},
            {@"&blank;", 9251.ToChar()},
            {@"&blk12;", 9618.ToChar()},
            {@"&blk14;", 9617.ToChar()},
            {@"&blk34;", 9619.ToChar()},
            {@"&block;", 9608.ToChar()},
            {@"&bne;", 61.ToChar()},
            {@"&bnequiv;", 8801.ToChar()},
            {@"&bNot;", 10989.ToChar()},
            {@"&bnot;", 8976.ToChar()},
//{ @"&Bopf;", 120121.ToChar() },
//{ @"&bopf;", 120147.ToChar() },
            {@"&bot;", 8869.ToChar()},
            {@"&bottom;", 8869.ToChar()},
            {@"&bowtie;", 8904.ToChar()},
            {@"&boxbox;", 10697.ToChar()},
            {@"&boxDL;", 9559.ToChar()},
            {@"&boxDl;", 9558.ToChar()},
            {@"&boxdL;", 9557.ToChar()},
            {@"&boxdl;", 9488.ToChar()},
            {@"&boxDR;", 9556.ToChar()},
            {@"&boxDr;", 9555.ToChar()},
            {@"&boxdR;", 9554.ToChar()},
            {@"&boxdr;", 9484.ToChar()},
            {@"&boxH;", 9552.ToChar()},
            {@"&boxh;", 9472.ToChar()},
            {@"&boxHD;", 9574.ToChar()},
            {@"&boxHd;", 9572.ToChar()},
            {@"&boxhD;", 9573.ToChar()},
            {@"&boxhd;", 9516.ToChar()},
            {@"&boxHU;", 9577.ToChar()},
            {@"&boxHu;", 9575.ToChar()},
            {@"&boxhU;", 9576.ToChar()},
            {@"&boxhu;", 9524.ToChar()},
            {@"&boxminus;", 8863.ToChar()},
            {@"&boxplus;", 8862.ToChar()},
            {@"&boxtimes;", 8864.ToChar()},
            {@"&boxUL;", 9565.ToChar()},
            {@"&boxUl;", 9564.ToChar()},
            {@"&boxuL;", 9563.ToChar()},
            {@"&boxul;", 9496.ToChar()},
            {@"&boxUR;", 9562.ToChar()},
            {@"&boxUr;", 9561.ToChar()},
            {@"&boxuR;", 9560.ToChar()},
            {@"&boxur;", 9492.ToChar()},
            {@"&boxV;", 9553.ToChar()},
            {@"&boxv;", 9474.ToChar()},
            {@"&boxVH;", 9580.ToChar()},
            {@"&boxVh;", 9579.ToChar()},
            {@"&boxvH;", 9578.ToChar()},
            {@"&boxvh;", 9532.ToChar()},
            {@"&boxVL;", 9571.ToChar()},
            {@"&boxVl;", 9570.ToChar()},
            {@"&boxvL;", 9569.ToChar()},
            {@"&boxvl;", 9508.ToChar()},
            {@"&boxVR;", 9568.ToChar()},
            {@"&boxVr;", 9567.ToChar()},
            {@"&boxvR;", 9566.ToChar()},
            {@"&boxvr;", 9500.ToChar()},
            {@"&bprime;", 8245.ToChar()},
            {@"&Breve;", 728.ToChar()},
            {@"&breve;", 728.ToChar()},
            {@"&brvbar;", 166.ToChar()},
            {@"&Bscr;", 8492.ToChar()},
//{ @"&bscr;", 119991.ToChar() },
            {@"&bsemi;", 8271.ToChar()},
            {@"&bsim;", 8765.ToChar()},
            {@"&bsime;", 8909.ToChar()},
            {@"&bsol;", 92.ToChar()},
            {@"&bsolb;", 10693.ToChar()},
            {@"&bsolhsub;", 10184.ToChar()},
            {@"&bull;", 8226.ToChar()},
            {@"&bullet;", 8226.ToChar()},
            {@"&bump;", 8782.ToChar()},
            {@"&bumpE;", 10926.ToChar()},
            {@"&bumpe;", 8783.ToChar()},
            {@"&Bumpeq;", 8782.ToChar()},
            {@"&bumpeq;", 8783.ToChar()},
            {@"&Cacute;", 262.ToChar()},
            {@"&cacute;", 263.ToChar()},
            {@"&Cap;", 8914.ToChar()},
            {@"&cap;", 8745.ToChar()},
            {@"&capand;", 10820.ToChar()},
            {@"&capbrcup;", 10825.ToChar()},
            {@"&capcap;", 10827.ToChar()},
            {@"&capcup;", 10823.ToChar()},
            {@"&capdot;", 10816.ToChar()},
            {@"&CapitalDifferentialD;", 8517.ToChar()},
            {@"&caps;", 8745.ToChar()},
            {@"&caret;", 8257.ToChar()},
            {@"&caron;", 711.ToChar()},
            {@"&Cayleys;", 8493.ToChar()},
            {@"&ccaps;", 10829.ToChar()},
            {@"&Ccaron;", 268.ToChar()},
            {@"&ccaron;", 269.ToChar()},
            {@"&Ccedil;", 199.ToChar()},
            {@"&ccedil;", 231.ToChar()},
            {@"&Ccirc;", 264.ToChar()},
            {@"&ccirc;", 265.ToChar()},
            {@"&Cconint;", 8752.ToChar()},
            {@"&ccups;", 10828.ToChar()},
            {@"&ccupssm;", 10832.ToChar()},
            {@"&Cdot;", 266.ToChar()},
            {@"&cdot;", 267.ToChar()},
            {@"&cedil;", 184.ToChar()},
            {@"&Cedilla;", 184.ToChar()},
            {@"&cemptyv;", 10674.ToChar()},
            {@"&cent;", 162.ToChar()},
            {@"&CenterDot;", 183.ToChar()},
            {@"&centerdot;", 183.ToChar()},
            {@"&Cfr;", 8493.ToChar()},
//{ @"&cfr;", 120096.ToChar() },
            {@"&CHcy;", 1063.ToChar()},
            {@"&chcy;", 1095.ToChar()},
            {@"&check;", 10003.ToChar()},
            {@"&checkmark;", 10003.ToChar()},
            {@"&Chi;", 935.ToChar()},
            {@"&chi;", 967.ToChar()},
            {@"&cir;", 9675.ToChar()},
            {@"&circ;", 710.ToChar()},
            {@"&circeq;", 8791.ToChar()},
            {@"&circlearrowleft;", 8634.ToChar()},
            {@"&circlearrowright;", 8635.ToChar()},
            {@"&circledast;", 8859.ToChar()},
            {@"&circledcirc;", 8858.ToChar()},
            {@"&circleddash;", 8861.ToChar()},
            {@"&CircleDot;", 8857.ToChar()},
            {@"&circledR;", 174.ToChar()},
            {@"&circledS;", 9416.ToChar()},
            {@"&CircleMinus;", 8854.ToChar()},
            {@"&CirclePlus;", 8853.ToChar()},
            {@"&CircleTimes;", 8855.ToChar()},
            {@"&cirE;", 10691.ToChar()},
            {@"&cire;", 8791.ToChar()},
            {@"&cirfnint;", 10768.ToChar()},
            {@"&cirmid;", 10991.ToChar()},
            {@"&cirscir;", 10690.ToChar()},
            {@"&ClockwiseContourIntegral;", 8754.ToChar()},
            {@"&CloseCurlyDoubleQuote;", 8221.ToChar()},
            {@"&CloseCurlyQuote;", 8217.ToChar()},
            {@"&clubs;", 9827.ToChar()},
            {@"&clubsuit;", 9827.ToChar()},
            {@"&Colon;", 8759.ToChar()},
            {@"&colon;", 58.ToChar()},
            {@"&Colone;", 10868.ToChar()},
            {@"&colone;", 8788.ToChar()},
            {@"&coloneq;", 8788.ToChar()},
            {@"&comma;", 44.ToChar()},
            {@"&commat;", 64.ToChar()},
            {@"&comp;", 8705.ToChar()},
            {@"&compfn;", 8728.ToChar()},
            {@"&complement;", 8705.ToChar()},
            {@"&complexes;", 8450.ToChar()},
            {@"&cong;", 8773.ToChar()},
            {@"&congdot;", 10861.ToChar()},
            {@"&Congruent;", 8801.ToChar()},
            {@"&Conint;", 8751.ToChar()},
            {@"&conint;", 8750.ToChar()},
            {@"&ContourIntegral;", 8750.ToChar()},
            {@"&Copf;", 8450.ToChar()},
//{ @"&copf;", 120148.ToChar() },
            {@"&coprod;", 8720.ToChar()},
            {@"&Coproduct;", 8720.ToChar()},
            {@"&COPY;", 169.ToChar()},
            {@"&copy;", 169.ToChar()},
            {@"&copysr;", 8471.ToChar()},
            {@"&CounterClockwiseContourIntegral;", 8755.ToChar()},
            {@"&crarr;", 8629.ToChar()},
            {@"&Cross;", 10799.ToChar()},
            {@"&cross;", 10007.ToChar()},
//{ @"&Cscr;", 119966.ToChar() },
//{ @"&cscr;", 119992.ToChar() },
            {@"&csub;", 10959.ToChar()},
            {@"&csube;", 10961.ToChar()},
            {@"&csup;", 10960.ToChar()},
            {@"&csupe;", 10962.ToChar()},
            {@"&ctdot;", 8943.ToChar()},
            {@"&cudarrl;", 10552.ToChar()},
            {@"&cudarrr;", 10549.ToChar()},
            {@"&cuepr;", 8926.ToChar()},
            {@"&cuesc;", 8927.ToChar()},
            {@"&cularr;", 8630.ToChar()},
            {@"&cularrp;", 10557.ToChar()},
            {@"&Cup;", 8915.ToChar()},
            {@"&cup;", 8746.ToChar()},
            {@"&cupbrcap;", 10824.ToChar()},
            {@"&CupCap;", 8781.ToChar()},
            {@"&cupcap;", 10822.ToChar()},
            {@"&cupcup;", 10826.ToChar()},
            {@"&cupdot;", 8845.ToChar()},
            {@"&cupor;", 10821.ToChar()},
            {@"&cups;", 8746.ToChar()},
            {@"&curarr;", 8631.ToChar()},
            {@"&curarrm;", 10556.ToChar()},
            {@"&curlyeqprec;", 8926.ToChar()},
            {@"&curlyeqsucc;", 8927.ToChar()},
            {@"&curlyvee;", 8910.ToChar()},
            {@"&curlywedge;", 8911.ToChar()},
            {@"&curren;", 164.ToChar()},
            {@"&curvearrowleft;", 8630.ToChar()},
            {@"&curvearrowright;", 8631.ToChar()},
            {@"&cuvee;", 8910.ToChar()},
            {@"&cuwed;", 8911.ToChar()},
            {@"&cwconint;", 8754.ToChar()},
            {@"&cwint;", 8753.ToChar()},
            {@"&cylcty;", 9005.ToChar()},
            {@"&Dagger;", 8225.ToChar()},
            {@"&dagger;", 8224.ToChar()},
            {@"&daleth;", 8504.ToChar()},
            {@"&Darr;", 8609.ToChar()},
            {@"&dArr;", 8659.ToChar()},
            {@"&darr;", 8595.ToChar()},
            {@"&dash;", 8208.ToChar()},
            {@"&Dashv;", 10980.ToChar()},
            {@"&dashv;", 8867.ToChar()},
            {@"&dbkarow;", 10511.ToChar()},
            {@"&dblac;", 733.ToChar()},
            {@"&Dcaron;", 270.ToChar()},
            {@"&dcaron;", 271.ToChar()},
            {@"&Dcy;", 1044.ToChar()},
            {@"&dcy;", 1076.ToChar()},
            {@"&DD;", 8517.ToChar()},
            {@"&dd;", 8518.ToChar()},
            {@"&ddagger;", 8225.ToChar()},
            {@"&ddarr;", 8650.ToChar()},
            {@"&DDotrahd;", 10513.ToChar()},
            {@"&ddotseq;", 10871.ToChar()},
            {@"&deg;", 176.ToChar()},
            {@"&Del;", 8711.ToChar()},
            {@"&Delta;", 916.ToChar()},
            {@"&delta;", 948.ToChar()},
            {@"&demptyv;", 10673.ToChar()},
            {@"&dfisht;", 10623.ToChar()},
//{ @"&Dfr;", 120071.ToChar() },
//{ @"&dfr;", 120097.ToChar() },
            {@"&dHar;", 10597.ToChar()},
            {@"&dharl;", 8643.ToChar()},
            {@"&dharr;", 8642.ToChar()},
            {@"&DiacriticalAcute;", 180.ToChar()},
            {@"&DiacriticalDot;", 729.ToChar()},
            {@"&DiacriticalDoubleAcute;", 733.ToChar()},
            {@"&DiacriticalGrave;", 96.ToChar()},
            {@"&DiacriticalTilde;", 732.ToChar()},
            {@"&diam;", 8900.ToChar()},
            {@"&Diamond;", 8900.ToChar()},
            {@"&diamond;", 8900.ToChar()},
            {@"&diamondsuit;", 9830.ToChar()},
            {@"&diams;", 9830.ToChar()},
            {@"&die;", 168.ToChar()},
            {@"&DifferentialD;", 8518.ToChar()},
            {@"&digamma;", 989.ToChar()},
            {@"&disin;", 8946.ToChar()},
            {@"&div;", 247.ToChar()},
            {@"&divide;", 247.ToChar()},
            {@"&divideontimes;", 8903.ToChar()},
            {@"&divonx;", 8903.ToChar()},
            {@"&DJcy;", 1026.ToChar()},
            {@"&djcy;", 1106.ToChar()},
            {@"&dlcorn;", 8990.ToChar()},
            {@"&dlcrop;", 8973.ToChar()},
            {@"&dollar;", 36.ToChar()},
//{ @"&Dopf;", 120123.ToChar() },
//{ @"&dopf;", 120149.ToChar() },
            {@"&Dot;", 168.ToChar()},
            {@"&dot;", 729.ToChar()},
            {@"&DotDot;", 8412.ToChar()},
            {@"&doteq;", 8784.ToChar()},
            {@"&doteqdot;", 8785.ToChar()},
            {@"&DotEqual;", 8784.ToChar()},
            {@"&dotminus;", 8760.ToChar()},
            {@"&dotplus;", 8724.ToChar()},
            {@"&dotsquare;", 8865.ToChar()},
            {@"&doublebarwedge;", 8966.ToChar()},
            {@"&DoubleContourIntegral;", 8751.ToChar()},
            {@"&DoubleDot;", 168.ToChar()},
            {@"&DoubleDownArrow;", 8659.ToChar()},
            {@"&DoubleLeftArrow;", 8656.ToChar()},
            {@"&DoubleLeftRightArrow;", 8660.ToChar()},
            {@"&DoubleLeftTee;", 10980.ToChar()},
            {@"&DoubleLongLeftArrow;", 10232.ToChar()},
            {@"&DoubleLongLeftRightArrow;", 10234.ToChar()},
            {@"&DoubleLongRightArrow;", 10233.ToChar()},
            {@"&DoubleRightArrow;", 8658.ToChar()},
            {@"&DoubleRightTee;", 8872.ToChar()},
            {@"&DoubleUpArrow;", 8657.ToChar()},
            {@"&DoubleUpDownArrow;", 8661.ToChar()},
            {@"&DoubleVerticalBar;", 8741.ToChar()},
            {@"&DownArrow;", 8595.ToChar()},
            {@"&Downarrow;", 8659.ToChar()},
            {@"&downarrow;", 8595.ToChar()},
            {@"&DownArrowBar;", 10515.ToChar()},
            {@"&DownArrowUpArrow;", 8693.ToChar()},
            {@"&DownBreve;", 785.ToChar()},
            {@"&downdownarrows;", 8650.ToChar()},
            {@"&downharpoonleft;", 8643.ToChar()},
            {@"&downharpoonright;", 8642.ToChar()},
            {@"&DownLeftRightVector;", 10576.ToChar()},
            {@"&DownLeftTeeVector;", 10590.ToChar()},
            {@"&DownLeftVector;", 8637.ToChar()},
            {@"&DownLeftVectorBar;", 10582.ToChar()},
            {@"&DownRightTeeVector;", 10591.ToChar()},
            {@"&DownRightVector;", 8641.ToChar()},
            {@"&DownRightVectorBar;", 10583.ToChar()},
            {@"&DownTee;", 8868.ToChar()},
            {@"&DownTeeArrow;", 8615.ToChar()},
            {@"&drbkarow;", 10512.ToChar()},
            {@"&drcorn;", 8991.ToChar()},
            {@"&drcrop;", 8972.ToChar()},
//{ @"&Dscr;", 119967.ToChar() },
//{ @"&dscr;", 119993.ToChar() },
            {@"&DScy;", 1029.ToChar()},
            {@"&dscy;", 1109.ToChar()},
            {@"&dsol;", 10742.ToChar()},
            {@"&Dstrok;", 272.ToChar()},
            {@"&dstrok;", 273.ToChar()},
            {@"&dtdot;", 8945.ToChar()},
            {@"&dtri;", 9663.ToChar()},
            {@"&dtrif;", 9662.ToChar()},
            {@"&duarr;", 8693.ToChar()},
            {@"&duhar;", 10607.ToChar()},
            {@"&dwangle;", 10662.ToChar()},
            {@"&DZcy;", 1039.ToChar()},
            {@"&dzcy;", 1119.ToChar()},
            {@"&dzigrarr;", 10239.ToChar()},
            {@"&Eacute;", 201.ToChar()},
            {@"&eacute;", 233.ToChar()},
            {@"&easter;", 10862.ToChar()},
            {@"&Ecaron;", 282.ToChar()},
            {@"&ecaron;", 283.ToChar()},
            {@"&ecir;", 8790.ToChar()},
            {@"&Ecirc;", 202.ToChar()},
            {@"&ecirc;", 234.ToChar()},
            {@"&ecolon;", 8789.ToChar()},
            {@"&Ecy;", 1069.ToChar()},
            {@"&ecy;", 1101.ToChar()},
            {@"&eDDot;", 10871.ToChar()},
            {@"&Edot;", 278.ToChar()},
            {@"&eDot;", 8785.ToChar()},
            {@"&edot;", 279.ToChar()},
            {@"&ee;", 8519.ToChar()},
            {@"&efDot;", 8786.ToChar()},
//{ @"&Efr;", 120072.ToChar() },
//{ @"&efr;", 120098.ToChar() },
            {@"&eg;", 10906.ToChar()},
            {@"&Egrave;", 200.ToChar()},
            {@"&egrave;", 232.ToChar()},
            {@"&egs;", 10902.ToChar()},
            {@"&egsdot;", 10904.ToChar()},
            {@"&el;", 10905.ToChar()},
            {@"&Element;", 8712.ToChar()},
            {@"&elinters;", 9191.ToChar()},
            {@"&ell;", 8467.ToChar()},
            {@"&els;", 10901.ToChar()},
            {@"&elsdot;", 10903.ToChar()},
            {@"&Emacr;", 274.ToChar()},
            {@"&emacr;", 275.ToChar()},
            {@"&empty;", 8709.ToChar()},
            {@"&emptyset;", 8709.ToChar()},
            {@"&EmptySmallSquare;", 9723.ToChar()},
            {@"&emptyv;", 8709.ToChar()},
            {@"&EmptyVerySmallSquare;", 9643.ToChar()},
            {@"&emsp;", 8195.ToChar()},
            {@"&emsp13;", 8196.ToChar()},
            {@"&emsp14;", 8197.ToChar()},
            {@"&ENG;", 330.ToChar()},
            {@"&eng;", 331.ToChar()},
            {@"&ensp;", 8194.ToChar()},
            {@"&Eogon;", 280.ToChar()},
            {@"&eogon;", 281.ToChar()},
//{ @"&Eopf;", 120124.ToChar() },
//{ @"&eopf;", 120150.ToChar() },
            {@"&epar;", 8917.ToChar()},
            {@"&eparsl;", 10723.ToChar()},
            {@"&eplus;", 10865.ToChar()},
            {@"&epsi;", 949.ToChar()},
            {@"&Epsilon;", 917.ToChar()},
            {@"&epsilon;", 949.ToChar()},
            {@"&epsiv;", 1013.ToChar()},
            {@"&eqcirc;", 8790.ToChar()},
            {@"&eqcolon;", 8789.ToChar()},
            {@"&eqsim;", 8770.ToChar()},
            {@"&eqslantgtr;", 10902.ToChar()},
            {@"&eqslantless;", 10901.ToChar()},
            {@"&Equal;", 10869.ToChar()},
            {@"&equals;", 61.ToChar()},
            {@"&EqualTilde;", 8770.ToChar()},
            {@"&equest;", 8799.ToChar()},
            {@"&Equilibrium;", 8652.ToChar()},
            {@"&equiv;", 8801.ToChar()},
            {@"&equivDD;", 10872.ToChar()},
            {@"&eqvparsl;", 10725.ToChar()},
            {@"&erarr;", 10609.ToChar()},
            {@"&erDot;", 8787.ToChar()},
            {@"&Escr;", 8496.ToChar()},
            {@"&escr;", 8495.ToChar()},
            {@"&esdot;", 8784.ToChar()},
            {@"&Esim;", 10867.ToChar()},
            {@"&esim;", 8770.ToChar()},
            {@"&Eta;", 919.ToChar()},
            {@"&eta;", 951.ToChar()},
            {@"&ETH;", 208.ToChar()},
            {@"&eth;", 240.ToChar()},
            {@"&Euml;", 203.ToChar()},
            {@"&euml;", 235.ToChar()},
            {@"&euro;", 8364.ToChar()},
            {@"&excl;", 33.ToChar()},
            {@"&exist;", 8707.ToChar()},
            {@"&Exists;", 8707.ToChar()},
            {@"&expectation;", 8496.ToChar()},
            {@"&ExponentialE;", 8519.ToChar()},
            {@"&exponentiale;", 8519.ToChar()},
            {@"&fallingdotseq;", 8786.ToChar()},
            {@"&Fcy;", 1060.ToChar()},
            {@"&fcy;", 1092.ToChar()},
            {@"&female;", 9792.ToChar()},
            {@"&ffilig;", 64259.ToChar()},
            {@"&fflig;", 64256.ToChar()},
            {@"&ffllig;", 64260.ToChar()},
//{ @"&Ffr;", 120073.ToChar() },
//{ @"&ffr;", 120099.ToChar() },
            {@"&filig;", 64257.ToChar()},
            {@"&FilledSmallSquare;", 9724.ToChar()},
            {@"&FilledVerySmallSquare;", 9642.ToChar()},
            {@"&fjlig;", 102.ToChar()},
            {@"&flat;", 9837.ToChar()},
            {@"&fllig;", 64258.ToChar()},
            {@"&fltns;", 9649.ToChar()},
            {@"&fnof;", 402.ToChar()},
//{ @"&Fopf;", 120125.ToChar() },
//{ @"&fopf;", 120151.ToChar() },
            {@"&ForAll;", 8704.ToChar()},
            {@"&forall;", 8704.ToChar()},
            {@"&fork;", 8916.ToChar()},
            {@"&forkv;", 10969.ToChar()},
            {@"&Fouriertrf;", 8497.ToChar()},
            {@"&fpartint;", 10765.ToChar()},
            {@"&frac12;", 189.ToChar()},
            {@"&frac13;", 8531.ToChar()},
            {@"&frac14;", 188.ToChar()},
            {@"&frac15;", 8533.ToChar()},
            {@"&frac16;", 8537.ToChar()},
            {@"&frac18;", 8539.ToChar()},
            {@"&frac23;", 8532.ToChar()},
            {@"&frac25;", 8534.ToChar()},
            {@"&frac34;", 190.ToChar()},
            {@"&frac35;", 8535.ToChar()},
            {@"&frac38;", 8540.ToChar()},
            {@"&frac45;", 8536.ToChar()},
            {@"&frac56;", 8538.ToChar()},
            {@"&frac58;", 8541.ToChar()},
            {@"&frac78;", 8542.ToChar()},
            {@"&frasl;", 8260.ToChar()},
            {@"&frown;", 8994.ToChar()},
            {@"&Fscr;", 8497.ToChar()},
//{ @"&fscr;", 119995.ToChar() },
            {@"&gacute;", 501.ToChar()},
            {@"&Gamma;", 915.ToChar()},
            {@"&gamma;", 947.ToChar()},
            {@"&Gammad;", 988.ToChar()},
            {@"&gammad;", 989.ToChar()},
            {@"&gap;", 10886.ToChar()},
            {@"&Gbreve;", 286.ToChar()},
            {@"&gbreve;", 287.ToChar()},
            {@"&Gcedil;", 290.ToChar()},
            {@"&Gcirc;", 284.ToChar()},
            {@"&gcirc;", 285.ToChar()},
            {@"&Gcy;", 1043.ToChar()},
            {@"&gcy;", 1075.ToChar()},
            {@"&Gdot;", 288.ToChar()},
            {@"&gdot;", 289.ToChar()},
            {@"&gE;", 8807.ToChar()},
            {@"&ge;", 8805.ToChar()},
            {@"&gEl;", 10892.ToChar()},
            {@"&gel;", 8923.ToChar()},
            {@"&geq;", 8805.ToChar()},
            {@"&geqq;", 8807.ToChar()},
            {@"&geqslant;", 10878.ToChar()},
            {@"&ges;", 10878.ToChar()},
            {@"&gescc;", 10921.ToChar()},
            {@"&gesdot;", 10880.ToChar()},
            {@"&gesdoto;", 10882.ToChar()},
            {@"&gesdotol;", 10884.ToChar()},
            {@"&gesl;", 8923.ToChar()},
            {@"&gesles;", 10900.ToChar()},
//{ @"&Gfr;", 120074.ToChar() },
//{ @"&gfr;", 120100.ToChar() },
            {@"&Gg;", 8921.ToChar()},
            {@"&gg;", 8811.ToChar()},
            {@"&ggg;", 8921.ToChar()},
            {@"&gimel;", 8503.ToChar()},
            {@"&GJcy;", 1027.ToChar()},
            {@"&gjcy;", 1107.ToChar()},
            {@"&gl;", 8823.ToChar()},
            {@"&gla;", 10917.ToChar()},
            {@"&glE;", 10898.ToChar()},
            {@"&glj;", 10916.ToChar()},
            {@"&gnap;", 10890.ToChar()},
            {@"&gnapprox;", 10890.ToChar()},
            {@"&gnE;", 8809.ToChar()},
            {@"&gne;", 10888.ToChar()},
            {@"&gneq;", 10888.ToChar()},
            {@"&gneqq;", 8809.ToChar()},
            {@"&gnsim;", 8935.ToChar()},
//{ @"&Gopf;", 120126.ToChar() },
//{ @"&gopf;", 120152.ToChar() },
            {@"&grave;", 96.ToChar()},
            {@"&GreaterEqual;", 8805.ToChar()},
            {@"&GreaterEqualLess;", 8923.ToChar()},
            {@"&GreaterFullEqual;", 8807.ToChar()},
            {@"&GreaterGreater;", 10914.ToChar()},
            {@"&GreaterLess;", 8823.ToChar()},
            {@"&GreaterSlantEqual;", 10878.ToChar()},
            {@"&GreaterTilde;", 8819.ToChar()},
//{ @"&Gscr;", 119970.ToChar() },
            {@"&gscr;", 8458.ToChar()},
            {@"&gsim;", 8819.ToChar()},
            {@"&gsime;", 10894.ToChar()},
            {@"&gsiml;", 10896.ToChar()},
            {@"&GT;", 62.ToChar()},
            {@"&Gt;", 8811.ToChar()},
            {@"&gt;", 62.ToChar()},
            {@"&gtcc;", 10919.ToChar()},
            {@"&gtcir;", 10874.ToChar()},
            {@"&gtdot;", 8919.ToChar()},
            {@"&gtlPar;", 10645.ToChar()},
            {@"&gtquest;", 10876.ToChar()},
            {@"&gtrapprox;", 10886.ToChar()},
            {@"&gtrarr;", 10616.ToChar()},
            {@"&gtrdot;", 8919.ToChar()},
            {@"&gtreqless;", 8923.ToChar()},
            {@"&gtreqqless;", 10892.ToChar()},
            {@"&gtrless;", 8823.ToChar()},
            {@"&gtrsim;", 8819.ToChar()},
            {@"&gvertneqq;", 8809.ToChar()},
            {@"&gvnE;", 8809.ToChar()},
            {@"&Hacek;", 711.ToChar()},
            {@"&hairsp;", 8202.ToChar()},
            {@"&half;", 189.ToChar()},
            {@"&hamilt;", 8459.ToChar()},
            {@"&HARDcy;", 1066.ToChar()},
            {@"&hardcy;", 1098.ToChar()},
            {@"&hArr;", 8660.ToChar()},
            {@"&harr;", 8596.ToChar()},
            {@"&harrcir;", 10568.ToChar()},
            {@"&harrw;", 8621.ToChar()},
            {@"&Hat;", 94.ToChar()},
            {@"&hbar;", 8463.ToChar()},
            {@"&Hcirc;", 292.ToChar()},
            {@"&hcirc;", 293.ToChar()},
            {@"&hearts;", 9829.ToChar()},
            {@"&heartsuit;", 9829.ToChar()},
            {@"&hellip;", 8230.ToChar()},
            {@"&hercon;", 8889.ToChar()},
            {@"&Hfr;", 8460.ToChar()},
//{ @"&hfr;", 120101.ToChar() },
            {@"&HilbertSpace;", 8459.ToChar()},
            {@"&hksearow;", 10533.ToChar()},
            {@"&hkswarow;", 10534.ToChar()},
            {@"&hoarr;", 8703.ToChar()},
            {@"&homtht;", 8763.ToChar()},
            {@"&hookleftarrow;", 8617.ToChar()},
            {@"&hookrightarrow;", 8618.ToChar()},
            {@"&Hopf;", 8461.ToChar()},
//{ @"&hopf;", 120153.ToChar() },
            {@"&horbar;", 8213.ToChar()},
            {@"&HorizontalLine;", 9472.ToChar()},
            {@"&Hscr;", 8459.ToChar()},
//{ @"&hscr;", 119997.ToChar() },
            {@"&hslash;", 8463.ToChar()},
            {@"&Hstrok;", 294.ToChar()},
            {@"&hstrok;", 295.ToChar()},
            {@"&HumpDownHump;", 8782.ToChar()},
            {@"&HumpEqual;", 8783.ToChar()},
            {@"&hybull;", 8259.ToChar()},
            {@"&hyphen;", 8208.ToChar()},
            {@"&Iacute;", 205.ToChar()},
            {@"&iacute;", 237.ToChar()},
            {@"&ic;", 8291.ToChar()},
            {@"&Icirc;", 206.ToChar()},
            {@"&icirc;", 238.ToChar()},
            {@"&Icy;", 1048.ToChar()},
            {@"&icy;", 1080.ToChar()},
            {@"&Idot;", 304.ToChar()},
            {@"&IEcy;", 1045.ToChar()},
            {@"&iecy;", 1077.ToChar()},
            {@"&iexcl;", 161.ToChar()},
            {@"&iff;", 8660.ToChar()},
            {@"&Ifr;", 8465.ToChar()},
//{ @"&ifr;", 120102.ToChar() },
            {@"&Igrave;", 204.ToChar()},
            {@"&igrave;", 236.ToChar()},
            {@"&ii;", 8520.ToChar()},
            {@"&iiiint;", 10764.ToChar()},
            {@"&iiint;", 8749.ToChar()},
            {@"&iinfin;", 10716.ToChar()},
            {@"&iiota;", 8489.ToChar()},
            {@"&IJlig;", 306.ToChar()},
            {@"&ijlig;", 307.ToChar()},
            {@"&Im;", 8465.ToChar()},
            {@"&Imacr;", 298.ToChar()},
            {@"&imacr;", 299.ToChar()},
            {@"&image;", 8465.ToChar()},
            {@"&ImaginaryI;", 8520.ToChar()},
            {@"&imagline;", 8464.ToChar()},
            {@"&imagpart;", 8465.ToChar()},
            {@"&imath;", 305.ToChar()},
            {@"&imof;", 8887.ToChar()},
            {@"&imped;", 437.ToChar()},
            {@"&Implies;", 8658.ToChar()},
            {@"&in;", 8712.ToChar()},
            {@"&incare;", 8453.ToChar()},
            {@"&infin;", 8734.ToChar()},
            {@"&infintie;", 10717.ToChar()},
            {@"&inodot;", 305.ToChar()},
            {@"&Int;", 8748.ToChar()},
            {@"&int;", 8747.ToChar()},
            {@"&intcal;", 8890.ToChar()},
            {@"&integers;", 8484.ToChar()},
            {@"&Integral;", 8747.ToChar()},
            {@"&intercal;", 8890.ToChar()},
            {@"&Intersection;", 8898.ToChar()},
            {@"&intlarhk;", 10775.ToChar()},
            {@"&intprod;", 10812.ToChar()},
            {@"&InvisibleComma;", 8291.ToChar()},
            {@"&InvisibleTimes;", 8290.ToChar()},
            {@"&IOcy;", 1025.ToChar()},
            {@"&iocy;", 1105.ToChar()},
            {@"&Iogon;", 302.ToChar()},
            {@"&iogon;", 303.ToChar()},
//{ @"&Iopf;", 120128.ToChar() },
//{ @"&iopf;", 120154.ToChar() },
            {@"&Iota;", 921.ToChar()},
            {@"&iota;", 953.ToChar()},
            {@"&iprod;", 10812.ToChar()},
            {@"&iquest;", 191.ToChar()},
            {@"&Iscr;", 8464.ToChar()},
//{ @"&iscr;", 119998.ToChar() },
            {@"&isin;", 8712.ToChar()},
            {@"&isindot;", 8949.ToChar()},
            {@"&isinE;", 8953.ToChar()},
            {@"&isins;", 8948.ToChar()},
            {@"&isinsv;", 8947.ToChar()},
            {@"&isinv;", 8712.ToChar()},
            {@"&it;", 8290.ToChar()},
            {@"&Itilde;", 296.ToChar()},
            {@"&itilde;", 297.ToChar()},
            {@"&Iukcy;", 1030.ToChar()},
            {@"&iukcy;", 1110.ToChar()},
            {@"&Iuml;", 207.ToChar()},
            {@"&iuml;", 239.ToChar()},
            {@"&Jcirc;", 308.ToChar()},
            {@"&jcirc;", 309.ToChar()},
            {@"&Jcy;", 1049.ToChar()},
            {@"&jcy;", 1081.ToChar()},
//{ @"&Jfr;", 120077.ToChar() },
//{ @"&jfr;", 120103.ToChar() },
            {@"&jmath;", 567.ToChar()},
//{ @"&Jopf;", 120129.ToChar() },
//{ @"&jopf;", 120155.ToChar() },
//{ @"&Jscr;", 119973.ToChar() },
//{ @"&jscr;", 119999.ToChar() },
            {@"&Jsercy;", 1032.ToChar()},
            {@"&jsercy;", 1112.ToChar()},
            {@"&Jukcy;", 1028.ToChar()},
            {@"&jukcy;", 1108.ToChar()},
            {@"&Kappa;", 922.ToChar()},
            {@"&kappa;", 954.ToChar()},
            {@"&kappav;", 1008.ToChar()},
            {@"&Kcedil;", 310.ToChar()},
            {@"&kcedil;", 311.ToChar()},
            {@"&Kcy;", 1050.ToChar()},
            {@"&kcy;", 1082.ToChar()},
//{ @"&Kfr;", 120078.ToChar() },
//{ @"&kfr;", 120104.ToChar() },
            {@"&kgreen;", 312.ToChar()},
            {@"&KHcy;", 1061.ToChar()},
            {@"&khcy;", 1093.ToChar()},
            {@"&KJcy;", 1036.ToChar()},
            {@"&kjcy;", 1116.ToChar()},
//{ @"&Kopf;", 120130.ToChar() },
//{ @"&kopf;", 120156.ToChar() },
//{ @"&Kscr;", 119974.ToChar() },
//{ @"&kscr;", 120000.ToChar() },
            {@"&lAarr;", 8666.ToChar()},
            {@"&Lacute;", 313.ToChar()},
            {@"&lacute;", 314.ToChar()},
            {@"&laemptyv;", 10676.ToChar()},
            {@"&lagran;", 8466.ToChar()},
            {@"&Lambda;", 923.ToChar()},
            {@"&lambda;", 955.ToChar()},
            {@"&Lang;", 10218.ToChar()},
            {@"&lang;", 10216.ToChar()},
            {@"&langd;", 10641.ToChar()},
            {@"&langle;", 10216.ToChar()},
            {@"&lap;", 10885.ToChar()},
            {@"&Laplacetrf;", 8466.ToChar()},
            {@"&laquo;", 171.ToChar()},
            {@"&Larr;", 8606.ToChar()},
            {@"&lArr;", 8656.ToChar()},
            {@"&larr;", 8592.ToChar()},
            {@"&larrb;", 8676.ToChar()},
            {@"&larrbfs;", 10527.ToChar()},
            {@"&larrfs;", 10525.ToChar()},
            {@"&larrhk;", 8617.ToChar()},
            {@"&larrlp;", 8619.ToChar()},
            {@"&larrpl;", 10553.ToChar()},
            {@"&larrsim;", 10611.ToChar()},
            {@"&larrtl;", 8610.ToChar()},
            {@"&lat;", 10923.ToChar()},
            {@"&lAtail;", 10523.ToChar()},
            {@"&latail;", 10521.ToChar()},
            {@"&late;", 10925.ToChar()},
            {@"&lates;", 10925.ToChar()},
            {@"&lBarr;", 10510.ToChar()},
            {@"&lbarr;", 10508.ToChar()},
            {@"&lbbrk;", 10098.ToChar()},
            {@"&lbrace;", 123.ToChar()},
            {@"&lbrack;", 91.ToChar()},
            {@"&lbrke;", 10635.ToChar()},
            {@"&lbrksld;", 10639.ToChar()},
            {@"&lbrkslu;", 10637.ToChar()},
            {@"&Lcaron;", 317.ToChar()},
            {@"&lcaron;", 318.ToChar()},
            {@"&Lcedil;", 315.ToChar()},
            {@"&lcedil;", 316.ToChar()},
            {@"&lceil;", 8968.ToChar()},
            {@"&lcub;", 123.ToChar()},
            {@"&Lcy;", 1051.ToChar()},
            {@"&lcy;", 1083.ToChar()},
            {@"&ldca;", 10550.ToChar()},
            {@"&ldquo;", 8220.ToChar()},
            {@"&ldquor;", 8222.ToChar()},
            {@"&ldrdhar;", 10599.ToChar()},
            {@"&ldrushar;", 10571.ToChar()},
            {@"&ldsh;", 8626.ToChar()},
            {@"&lE;", 8806.ToChar()},
            {@"&le;", 8804.ToChar()},
            {@"&LeftAngleBracket;", 10216.ToChar()},
            {@"&LeftArrow;", 8592.ToChar()},
            {@"&Leftarrow;", 8656.ToChar()},
            {@"&leftarrow;", 8592.ToChar()},
            {@"&LeftArrowBar;", 8676.ToChar()},
            {@"&LeftArrowRightArrow;", 8646.ToChar()},
            {@"&leftarrowtail;", 8610.ToChar()},
            {@"&LeftCeiling;", 8968.ToChar()},
            {@"&LeftDoubleBracket;", 10214.ToChar()},
            {@"&LeftDownTeeVector;", 10593.ToChar()},
            {@"&LeftDownVector;", 8643.ToChar()},
            {@"&LeftDownVectorBar;", 10585.ToChar()},
            {@"&LeftFloor;", 8970.ToChar()},
            {@"&leftharpoondown;", 8637.ToChar()},
            {@"&leftharpoonup;", 8636.ToChar()},
            {@"&leftleftarrows;", 8647.ToChar()},
            {@"&LeftRightArrow;", 8596.ToChar()},
            {@"&Leftrightarrow;", 8660.ToChar()},
            {@"&leftrightarrow;", 8596.ToChar()},
            {@"&leftrightarrows;", 8646.ToChar()},
            {@"&leftrightharpoons;", 8651.ToChar()},
            {@"&leftrightsquigarrow;", 8621.ToChar()},
            {@"&LeftRightVector;", 10574.ToChar()},
            {@"&LeftTee;", 8867.ToChar()},
            {@"&LeftTeeArrow;", 8612.ToChar()},
            {@"&LeftTeeVector;", 10586.ToChar()},
            {@"&leftthreetimes;", 8907.ToChar()},
            {@"&LeftTriangle;", 8882.ToChar()},
            {@"&LeftTriangleBar;", 10703.ToChar()},
            {@"&LeftTriangleEqual;", 8884.ToChar()},
            {@"&LeftUpDownVector;", 10577.ToChar()},
            {@"&LeftUpTeeVector;", 10592.ToChar()},
            {@"&LeftUpVector;", 8639.ToChar()},
            {@"&LeftUpVectorBar;", 10584.ToChar()},
            {@"&LeftVector;", 8636.ToChar()},
            {@"&LeftVectorBar;", 10578.ToChar()},
            {@"&lEg;", 10891.ToChar()},
            {@"&leg;", 8922.ToChar()},
            {@"&leq;", 8804.ToChar()},
            {@"&leqq;", 8806.ToChar()},
            {@"&leqslant;", 10877.ToChar()},
            {@"&les;", 10877.ToChar()},
            {@"&lescc;", 10920.ToChar()},
            {@"&lesdot;", 10879.ToChar()},
            {@"&lesdoto;", 10881.ToChar()},
            {@"&lesdotor;", 10883.ToChar()},
            {@"&lesg;", 8922.ToChar()},
            {@"&lesges;", 10899.ToChar()},
            {@"&lessapprox;", 10885.ToChar()},
            {@"&lessdot;", 8918.ToChar()},
            {@"&lesseqgtr;", 8922.ToChar()},
            {@"&lesseqqgtr;", 10891.ToChar()},
            {@"&LessEqualGreater;", 8922.ToChar()},
            {@"&LessFullEqual;", 8806.ToChar()},
            {@"&LessGreater;", 8822.ToChar()},
            {@"&lessgtr;", 8822.ToChar()},
            {@"&LessLess;", 10913.ToChar()},
            {@"&lesssim;", 8818.ToChar()},
            {@"&LessSlantEqual;", 10877.ToChar()},
            {@"&LessTilde;", 8818.ToChar()},
            {@"&lfisht;", 10620.ToChar()},
            {@"&lfloor;", 8970.ToChar()},
//{ @"&Lfr;", 120079.ToChar() },
//{ @"&lfr;", 120105.ToChar() },
            {@"&lg;", 8822.ToChar()},
            {@"&lgE;", 10897.ToChar()},
            {@"&lHar;", 10594.ToChar()},
            {@"&lhard;", 8637.ToChar()},
            {@"&lharu;", 8636.ToChar()},
            {@"&lharul;", 10602.ToChar()},
            {@"&lhblk;", 9604.ToChar()},
            {@"&LJcy;", 1033.ToChar()},
            {@"&ljcy;", 1113.ToChar()},
            {@"&Ll;", 8920.ToChar()},
            {@"&ll;", 8810.ToChar()},
            {@"&llarr;", 8647.ToChar()},
            {@"&llcorner;", 8990.ToChar()},
            {@"&Lleftarrow;", 8666.ToChar()},
            {@"&llhard;", 10603.ToChar()},
            {@"&lltri;", 9722.ToChar()},
            {@"&Lmidot;", 319.ToChar()},
            {@"&lmidot;", 320.ToChar()},
            {@"&lmoust;", 9136.ToChar()},
            {@"&lmoustache;", 9136.ToChar()},
            {@"&lnap;", 10889.ToChar()},
            {@"&lnapprox;", 10889.ToChar()},
            {@"&lnE;", 8808.ToChar()},
            {@"&lne;", 10887.ToChar()},
            {@"&lneq;", 10887.ToChar()},
            {@"&lneqq;", 8808.ToChar()},
            {@"&lnsim;", 8934.ToChar()},
            {@"&loang;", 10220.ToChar()},
            {@"&loarr;", 8701.ToChar()},
            {@"&lobrk;", 10214.ToChar()},
            {@"&LongLeftArrow;", 10229.ToChar()},
            {@"&Longleftarrow;", 10232.ToChar()},
            {@"&longleftarrow;", 10229.ToChar()},
            {@"&LongLeftRightArrow;", 10231.ToChar()},
            {@"&Longleftrightarrow;", 10234.ToChar()},
            {@"&longleftrightarrow;", 10231.ToChar()},
            {@"&longmapsto;", 10236.ToChar()},
            {@"&LongRightArrow;", 10230.ToChar()},
            {@"&Longrightarrow;", 10233.ToChar()},
            {@"&longrightarrow;", 10230.ToChar()},
            {@"&looparrowleft;", 8619.ToChar()},
            {@"&looparrowright;", 8620.ToChar()},
            {@"&lopar;", 10629.ToChar()},
//{ @"&Lopf;", 120131.ToChar() },
//{ @"&lopf;", 120157.ToChar() },
            {@"&loplus;", 10797.ToChar()},
            {@"&lotimes;", 10804.ToChar()},
            {@"&lowast;", 8727.ToChar()},
            {@"&lowbar;", 95.ToChar()},
            {@"&LowerLeftArrow;", 8601.ToChar()},
            {@"&LowerRightArrow;", 8600.ToChar()},
            {@"&loz;", 9674.ToChar()},
            {@"&lozenge;", 9674.ToChar()},
            {@"&lozf;", 10731.ToChar()},
            {@"&lpar;", 40.ToChar()},
            {@"&lparlt;", 10643.ToChar()},
            {@"&lrarr;", 8646.ToChar()},
            {@"&lrcorner;", 8991.ToChar()},
            {@"&lrhar;", 8651.ToChar()},
            {@"&lrhard;", 10605.ToChar()},
            {@"&lrm;", 8206.ToChar()},
            {@"&lrtri;", 8895.ToChar()},
            {@"&lsaquo;", 8249.ToChar()},
            {@"&Lscr;", 8466.ToChar()},
//{ @"&lscr;", 120001.ToChar() },
            {@"&Lsh;", 8624.ToChar()},
            {@"&lsh;", 8624.ToChar()},
            {@"&lsim;", 8818.ToChar()},
            {@"&lsime;", 10893.ToChar()},
            {@"&lsimg;", 10895.ToChar()},
            {@"&lsqb;", 91.ToChar()},
            {@"&lsquo;", 8216.ToChar()},
            {@"&lsquor;", 8218.ToChar()},
            {@"&Lstrok;", 321.ToChar()},
            {@"&lstrok;", 322.ToChar()},
            {@"&LT;", 60.ToChar()},
            {@"&Lt;", 8810.ToChar()},
            {@"&lt;", 60.ToChar()},
            {@"&ltcc;", 10918.ToChar()},
            {@"&ltcir;", 10873.ToChar()},
            {@"&ltdot;", 8918.ToChar()},
            {@"&lthree;", 8907.ToChar()},
            {@"&ltimes;", 8905.ToChar()},
            {@"&ltlarr;", 10614.ToChar()},
            {@"&ltquest;", 10875.ToChar()},
            {@"&ltri;", 9667.ToChar()},
            {@"&ltrie;", 8884.ToChar()},
            {@"&ltrif;", 9666.ToChar()},
            {@"&ltrPar;", 10646.ToChar()},
            {@"&lurdshar;", 10570.ToChar()},
            {@"&luruhar;", 10598.ToChar()},
            {@"&lvertneqq;", 8808.ToChar()},
            {@"&lvnE;", 8808.ToChar()},
            {@"&macr;", 175.ToChar()},
            {@"&male;", 9794.ToChar()},
            {@"&malt;", 10016.ToChar()},
            {@"&maltese;", 10016.ToChar()},
            {@"&Map;", 10501.ToChar()},
            {@"&map;", 8614.ToChar()},
            {@"&mapsto;", 8614.ToChar()},
            {@"&mapstodown;", 8615.ToChar()},
            {@"&mapstoleft;", 8612.ToChar()},
            {@"&mapstoup;", 8613.ToChar()},
            {@"&marker;", 9646.ToChar()},
            {@"&mcomma;", 10793.ToChar()},
            {@"&Mcy;", 1052.ToChar()},
            {@"&mcy;", 1084.ToChar()},
            {@"&mdash;", 8212.ToChar()},
            {@"&mDDot;", 8762.ToChar()},
            {@"&measuredangle;", 8737.ToChar()},
            {@"&MediumSpace;", 8287.ToChar()},
            {@"&Mellintrf;", 8499.ToChar()},
//{ @"&Mfr;", 120080.ToChar() },
//{ @"&mfr;", 120106.ToChar() },
            {@"&mho;", 8487.ToChar()},
            {@"&micro;", 181.ToChar()},
            {@"&mid;", 8739.ToChar()},
            {@"&midast;", 42.ToChar()},
            {@"&midcir;", 10992.ToChar()},
            {@"&middot;", 183.ToChar()},
            {@"&minus;", 8722.ToChar()},
            {@"&minusb;", 8863.ToChar()},
            {@"&minusd;", 8760.ToChar()},
            {@"&minusdu;", 10794.ToChar()},
            {@"&MinusPlus;", 8723.ToChar()},
            {@"&mlcp;", 10971.ToChar()},
            {@"&mldr;", 8230.ToChar()},
            {@"&mnplus;", 8723.ToChar()},
            {@"&models;", 8871.ToChar()},
//{ @"&Mopf;", 120132.ToChar() },
//{ @"&mopf;", 120158.ToChar() },
            {@"&mp;", 8723.ToChar()},
            {@"&Mscr;", 8499.ToChar()},
//{ @"&mscr;", 120002.ToChar() },
            {@"&mstpos;", 8766.ToChar()},
            {@"&Mu;", 924.ToChar()},
            {@"&mu;", 956.ToChar()},
            {@"&multimap;", 8888.ToChar()},
            {@"&mumap;", 8888.ToChar()},
            {@"&nabla;", 8711.ToChar()},
            {@"&Nacute;", 323.ToChar()},
            {@"&nacute;", 324.ToChar()},
            {@"&nang;", 8736.ToChar()},
            {@"&nap;", 8777.ToChar()},
            {@"&napE;", 10864.ToChar()},
            {@"&napid;", 8779.ToChar()},
            {@"&napos;", 329.ToChar()},
            {@"&napprox;", 8777.ToChar()},
            {@"&natur;", 9838.ToChar()},
            {@"&natural;", 9838.ToChar()},
            {@"&naturals;", 8469.ToChar()},
            {@"&nbsp;", 160.ToChar()},
            {@"&nbump;", 8782.ToChar()},
            {@"&nbumpe;", 8783.ToChar()},
            {@"&ncap;", 10819.ToChar()},
            {@"&Ncaron;", 327.ToChar()},
            {@"&ncaron;", 328.ToChar()},
            {@"&Ncedil;", 325.ToChar()},
            {@"&ncedil;", 326.ToChar()},
            {@"&ncong;", 8775.ToChar()},
            {@"&ncongdot;", 10861.ToChar()},
            {@"&ncup;", 10818.ToChar()},
            {@"&Ncy;", 1053.ToChar()},
            {@"&ncy;", 1085.ToChar()},
            {@"&ndash;", 8211.ToChar()},
            {@"&ne;", 8800.ToChar()},
            {@"&nearhk;", 10532.ToChar()},
            {@"&neArr;", 8663.ToChar()},
            {@"&nearr;", 8599.ToChar()},
            {@"&nearrow;", 8599.ToChar()},
            {@"&nedot;", 8784.ToChar()},
            {@"&NegativeMediumSpace;", 8203.ToChar()},
            {@"&NegativeThickSpace;", 8203.ToChar()},
            {@"&NegativeThinSpace;", 8203.ToChar()},
            {@"&NegativeVeryThinSpace;", 8203.ToChar()},
            {@"&nequiv;", 8802.ToChar()},
            {@"&nesear;", 10536.ToChar()},
            {@"&nesim;", 8770.ToChar()},
            {@"&NestedGreaterGreater;", 8811.ToChar()},
            {@"&NestedLessLess;", 8810.ToChar()},
            {@"&NewLine;", 10.ToChar()},
            {@"&nexist;", 8708.ToChar()},
            {@"&nexists;", 8708.ToChar()},
//{ @"&Nfr;", 120081.ToChar() },
//{ @"&nfr;", 120107.ToChar() },
            {@"&ngE;", 8807.ToChar()},
            {@"&nge;", 8817.ToChar()},
            {@"&ngeq;", 8817.ToChar()},
            {@"&ngeqq;", 8807.ToChar()},
            {@"&ngeqslant;", 10878.ToChar()},
            {@"&nges;", 10878.ToChar()},
            {@"&nGg;", 8921.ToChar()},
            {@"&ngsim;", 8821.ToChar()},
            {@"&nGt;", 8811.ToChar()},
            {@"&ngt;", 8815.ToChar()},
            {@"&ngtr;", 8815.ToChar()},
            {@"&nGtv;", 8811.ToChar()},
            {@"&nhArr;", 8654.ToChar()},
            {@"&nharr;", 8622.ToChar()},
            {@"&nhpar;", 10994.ToChar()},
            {@"&ni;", 8715.ToChar()},
            {@"&nis;", 8956.ToChar()},
            {@"&nisd;", 8954.ToChar()},
            {@"&niv;", 8715.ToChar()},
            {@"&NJcy;", 1034.ToChar()},
            {@"&njcy;", 1114.ToChar()},
            {@"&nlArr;", 8653.ToChar()},
            {@"&nlarr;", 8602.ToChar()},
            {@"&nldr;", 8229.ToChar()},
            {@"&nlE;", 8806.ToChar()},
            {@"&nle;", 8816.ToChar()},
            {@"&nLeftarrow;", 8653.ToChar()},
            {@"&nleftarrow;", 8602.ToChar()},
            {@"&nLeftrightarrow;", 8654.ToChar()},
            {@"&nleftrightarrow;", 8622.ToChar()},
            {@"&nleq;", 8816.ToChar()},
            {@"&nleqq;", 8806.ToChar()},
            {@"&nleqslant;", 10877.ToChar()},
            {@"&nles;", 10877.ToChar()},
            {@"&nless;", 8814.ToChar()},
            {@"&nLl;", 8920.ToChar()},
            {@"&nlsim;", 8820.ToChar()},
            {@"&nLt;", 8810.ToChar()},
            {@"&nlt;", 8814.ToChar()},
            {@"&nltri;", 8938.ToChar()},
            {@"&nltrie;", 8940.ToChar()},
            {@"&nLtv;", 8810.ToChar()},
            {@"&nmid;", 8740.ToChar()},
            {@"&NoBreak;", 8288.ToChar()},
            {@"&NonBreakingSpace;", 160.ToChar()},
            {@"&Nopf;", 8469.ToChar()},
//{ @"&nopf;", 120159.ToChar() },
            {@"&Not;", 10988.ToChar()},
            {@"&not;", 172.ToChar()},
            {@"&NotCongruent;", 8802.ToChar()},
            {@"&NotCupCap;", 8813.ToChar()},
            {@"&NotDoubleVerticalBar;", 8742.ToChar()},
            {@"&NotElement;", 8713.ToChar()},
            {@"&NotEqual;", 8800.ToChar()},
            {@"&NotEqualTilde;", 8770.ToChar()},
            {@"&NotExists;", 8708.ToChar()},
            {@"&NotGreater;", 8815.ToChar()},
            {@"&NotGreaterEqual;", 8817.ToChar()},
            {@"&NotGreaterFullEqual;", 8807.ToChar()},
            {@"&NotGreaterGreater;", 8811.ToChar()},
            {@"&NotGreaterLess;", 8825.ToChar()},
            {@"&NotGreaterSlantEqual;", 10878.ToChar()},
            {@"&NotGreaterTilde;", 8821.ToChar()},
            {@"&NotHumpDownHump;", 8782.ToChar()},
            {@"&NotHumpEqual;", 8783.ToChar()},
            {@"&notin;", 8713.ToChar()},
            {@"&notindot;", 8949.ToChar()},
            {@"&notinE;", 8953.ToChar()},
            {@"&notinva;", 8713.ToChar()},
            {@"&notinvb;", 8951.ToChar()},
            {@"&notinvc;", 8950.ToChar()},
            {@"&NotLeftTriangle;", 8938.ToChar()},
            {@"&NotLeftTriangleBar;", 10703.ToChar()},
            {@"&NotLeftTriangleEqual;", 8940.ToChar()},
            {@"&NotLess;", 8814.ToChar()},
            {@"&NotLessEqual;", 8816.ToChar()},
            {@"&NotLessGreater;", 8824.ToChar()},
            {@"&NotLessLess;", 8810.ToChar()},
            {@"&NotLessSlantEqual;", 10877.ToChar()},
            {@"&NotLessTilde;", 8820.ToChar()},
            {@"&NotNestedGreaterGreater;", 10914.ToChar()},
            {@"&NotNestedLessLess;", 10913.ToChar()},
            {@"&notni;", 8716.ToChar()},
            {@"&notniva;", 8716.ToChar()},
            {@"&notnivb;", 8958.ToChar()},
            {@"&notnivc;", 8957.ToChar()},
            {@"&NotPrecedes;", 8832.ToChar()},
            {@"&NotPrecedesEqual;", 10927.ToChar()},
            {@"&NotPrecedesSlantEqual;", 8928.ToChar()},
            {@"&NotReverseElement;", 8716.ToChar()},
            {@"&NotRightTriangle;", 8939.ToChar()},
            {@"&NotRightTriangleBar;", 10704.ToChar()},
            {@"&NotRightTriangleEqual;", 8941.ToChar()},
            {@"&NotSquareSubset;", 8847.ToChar()},
            {@"&NotSquareSubsetEqual;", 8930.ToChar()},
            {@"&NotSquareSuperset;", 8848.ToChar()},
            {@"&NotSquareSupersetEqual;", 8931.ToChar()},
            {@"&NotSubset;", 8834.ToChar()},
            {@"&NotSubsetEqual;", 8840.ToChar()},
            {@"&NotSucceeds;", 8833.ToChar()},
            {@"&NotSucceedsEqual;", 10928.ToChar()},
            {@"&NotSucceedsSlantEqual;", 8929.ToChar()},
            {@"&NotSucceedsTilde;", 8831.ToChar()},
            {@"&NotSuperset;", 8835.ToChar()},
            {@"&NotSupersetEqual;", 8841.ToChar()},
            {@"&NotTilde;", 8769.ToChar()},
            {@"&NotTildeEqual;", 8772.ToChar()},
            {@"&NotTildeFullEqual;", 8775.ToChar()},
            {@"&NotTildeTilde;", 8777.ToChar()},
            {@"&NotVerticalBar;", 8740.ToChar()},
            {@"&npar;", 8742.ToChar()},
            {@"&nparallel;", 8742.ToChar()},
            {@"&nparsl;", 11005.ToChar()},
            {@"&npart;", 8706.ToChar()},
            {@"&npolint;", 10772.ToChar()},
            {@"&npr;", 8832.ToChar()},
            {@"&nprcue;", 8928.ToChar()},
            {@"&npre;", 10927.ToChar()},
            {@"&nprec;", 8832.ToChar()},
            {@"&npreceq;", 10927.ToChar()},
            {@"&nrArr;", 8655.ToChar()},
            {@"&nrarr;", 8603.ToChar()},
            {@"&nrarrc;", 10547.ToChar()},
            {@"&nrarrw;", 8605.ToChar()},
            {@"&nRightarrow;", 8655.ToChar()},
            {@"&nrightarrow;", 8603.ToChar()},
            {@"&nrtri;", 8939.ToChar()},
            {@"&nrtrie;", 8941.ToChar()},
            {@"&nsc;", 8833.ToChar()},
            {@"&nsccue;", 8929.ToChar()},
            {@"&nsce;", 10928.ToChar()},
//{ @"&Nscr;", 119977.ToChar() },
//{ @"&nscr;", 120003.ToChar() },
            {@"&nshortmid;", 8740.ToChar()},
            {@"&nshortparallel;", 8742.ToChar()},
            {@"&nsim;", 8769.ToChar()},
            {@"&nsime;", 8772.ToChar()},
            {@"&nsimeq;", 8772.ToChar()},
            {@"&nsmid;", 8740.ToChar()},
            {@"&nspar;", 8742.ToChar()},
            {@"&nsqsube;", 8930.ToChar()},
            {@"&nsqsupe;", 8931.ToChar()},
            {@"&nsub;", 8836.ToChar()},
            {@"&nsubE;", 10949.ToChar()},
            {@"&nsube;", 8840.ToChar()},
            {@"&nsubset;", 8834.ToChar()},
            {@"&nsubseteq;", 8840.ToChar()},
            {@"&nsubseteqq;", 10949.ToChar()},
            {@"&nsucc;", 8833.ToChar()},
            {@"&nsucceq;", 10928.ToChar()},
            {@"&nsup;", 8837.ToChar()},
            {@"&nsupE;", 10950.ToChar()},
            {@"&nsupe;", 8841.ToChar()},
            {@"&nsupset;", 8835.ToChar()},
            {@"&nsupseteq;", 8841.ToChar()},
            {@"&nsupseteqq;", 10950.ToChar()},
            {@"&ntgl;", 8825.ToChar()},
            {@"&Ntilde;", 209.ToChar()},
            {@"&ntilde;", 241.ToChar()},
            {@"&ntlg;", 8824.ToChar()},
            {@"&ntriangleleft;", 8938.ToChar()},
            {@"&ntrianglelefteq;", 8940.ToChar()},
            {@"&ntriangleright;", 8939.ToChar()},
            {@"&ntrianglerighteq;", 8941.ToChar()},
            {@"&Nu;", 925.ToChar()},
            {@"&nu;", 957.ToChar()},
            {@"&num;", 35.ToChar()},
            {@"&numero;", 8470.ToChar()},
            {@"&numsp;", 8199.ToChar()},
            {@"&nvap;", 8781.ToChar()},
            {@"&nVDash;", 8879.ToChar()},
            {@"&nVdash;", 8878.ToChar()},
            {@"&nvDash;", 8877.ToChar()},
            {@"&nvdash;", 8876.ToChar()},
            {@"&nvge;", 8805.ToChar()},
            {@"&nvgt;", 62.ToChar()},
            {@"&nvHarr;", 10500.ToChar()},
            {@"&nvinfin;", 10718.ToChar()},
            {@"&nvlArr;", 10498.ToChar()},
            {@"&nvle;", 8804.ToChar()},
            {@"&nvlt;", 60.ToChar()},
            {@"&nvltrie;", 8884.ToChar()},
            {@"&nvrArr;", 10499.ToChar()},
            {@"&nvrtrie;", 8885.ToChar()},
            {@"&nvsim;", 8764.ToChar()},
            {@"&nwarhk;", 10531.ToChar()},
            {@"&nwArr;", 8662.ToChar()},
            {@"&nwarr;", 8598.ToChar()},
            {@"&nwarrow;", 8598.ToChar()},
            {@"&nwnear;", 10535.ToChar()},
            {@"&Oacute;", 211.ToChar()},
            {@"&oacute;", 243.ToChar()},
            {@"&oast;", 8859.ToChar()},
            {@"&ocir;", 8858.ToChar()},
            {@"&Ocirc;", 212.ToChar()},
            {@"&ocirc;", 244.ToChar()},
            {@"&Ocy;", 1054.ToChar()},
            {@"&ocy;", 1086.ToChar()},
            {@"&odash;", 8861.ToChar()},
            {@"&Odblac;", 336.ToChar()},
            {@"&odblac;", 337.ToChar()},
            {@"&odiv;", 10808.ToChar()},
            {@"&odot;", 8857.ToChar()},
            {@"&odsold;", 10684.ToChar()},
            {@"&OElig;", 338.ToChar()},
            {@"&oelig;", 339.ToChar()},
            {@"&ofcir;", 10687.ToChar()},
//{ @"&Ofr;", 120082.ToChar() },
//{ @"&ofr;", 120108.ToChar() },
            {@"&ogon;", 731.ToChar()},
            {@"&Ograve;", 210.ToChar()},
            {@"&ograve;", 242.ToChar()},
            {@"&ogt;", 10689.ToChar()},
            {@"&ohbar;", 10677.ToChar()},
            {@"&ohm;", 937.ToChar()},
            {@"&oint;", 8750.ToChar()},
            {@"&olarr;", 8634.ToChar()},
            {@"&olcir;", 10686.ToChar()},
            {@"&olcross;", 10683.ToChar()},
            {@"&oline;", 8254.ToChar()},
            {@"&olt;", 10688.ToChar()},
            {@"&Omacr;", 332.ToChar()},
            {@"&omacr;", 333.ToChar()},
            {@"&Omega;", 937.ToChar()},
            {@"&omega;", 969.ToChar()},
            {@"&Omicron;", 927.ToChar()},
            {@"&omicron;", 959.ToChar()},
            {@"&omid;", 10678.ToChar()},
            {@"&ominus;", 8854.ToChar()},
//{ @"&Oopf;", 120134.ToChar() },
//{ @"&oopf;", 120160.ToChar() },
            {@"&opar;", 10679.ToChar()},
            {@"&OpenCurlyDoubleQuote;", 8220.ToChar()},
            {@"&OpenCurlyQuote;", 8216.ToChar()},
            {@"&operp;", 10681.ToChar()},
            {@"&oplus;", 8853.ToChar()},
            {@"&Or;", 10836.ToChar()},
            {@"&or;", 8744.ToChar()},
            {@"&orarr;", 8635.ToChar()},
            {@"&ord;", 10845.ToChar()},
            {@"&order;", 8500.ToChar()},
            {@"&orderof;", 8500.ToChar()},
            {@"&ordf;", 170.ToChar()},
            {@"&ordm;", 186.ToChar()},
            {@"&origof;", 8886.ToChar()},
            {@"&oror;", 10838.ToChar()},
            {@"&orslope;", 10839.ToChar()},
            {@"&orv;", 10843.ToChar()},
            {@"&oS;", 9416.ToChar()},
//{ @"&Oscr;", 119978.ToChar() },
            {@"&oscr;", 8500.ToChar()},
            {@"&Oslash;", 216.ToChar()},
            {@"&oslash;", 248.ToChar()},
            {@"&osol;", 8856.ToChar()},
            {@"&Otilde;", 213.ToChar()},
            {@"&otilde;", 245.ToChar()},
            {@"&Otimes;", 10807.ToChar()},
            {@"&otimes;", 8855.ToChar()},
            {@"&otimesas;", 10806.ToChar()},
            {@"&Ouml;", 214.ToChar()},
            {@"&ouml;", 246.ToChar()},
            {@"&ovbar;", 9021.ToChar()},
            {@"&OverBar;", 8254.ToChar()},
            {@"&OverBrace;", 9182.ToChar()},
            {@"&OverBracket;", 9140.ToChar()},
            {@"&OverParenthesis;", 9180.ToChar()},
            {@"&par;", 8741.ToChar()},
            {@"&para;", 182.ToChar()},
            {@"&parallel;", 8741.ToChar()},
            {@"&parsim;", 10995.ToChar()},
            {@"&parsl;", 11005.ToChar()},
            {@"&part;", 8706.ToChar()},
            {@"&PartialD;", 8706.ToChar()},
            {@"&Pcy;", 1055.ToChar()},
            {@"&pcy;", 1087.ToChar()},
            {@"&percnt;", 37.ToChar()},
            {@"&period;", 46.ToChar()},
            {@"&permil;", 8240.ToChar()},
            {@"&perp;", 8869.ToChar()},
            {@"&pertenk;", 8241.ToChar()},
//{ @"&Pfr;", 120083.ToChar() },
//{ @"&pfr;", 120109.ToChar() },
            {@"&Phi;", 934.ToChar()},
            {@"&phi;", 966.ToChar()},
            {@"&phiv;", 981.ToChar()},
            {@"&phmmat;", 8499.ToChar()},
            {@"&phone;", 9742.ToChar()},
            {@"&Pi;", 928.ToChar()},
            {@"&pi;", 960.ToChar()},
            {@"&pitchfork;", 8916.ToChar()},
            {@"&piv;", 982.ToChar()},
            {@"&planck;", 8463.ToChar()},
            {@"&planckh;", 8462.ToChar()},
            {@"&plankv;", 8463.ToChar()},
            {@"&plus;", 43.ToChar()},
            {@"&plusacir;", 10787.ToChar()},
            {@"&plusb;", 8862.ToChar()},
            {@"&pluscir;", 10786.ToChar()},
            {@"&plusdo;", 8724.ToChar()},
            {@"&plusdu;", 10789.ToChar()},
            {@"&pluse;", 10866.ToChar()},
            {@"&PlusMinus;", 177.ToChar()},
            {@"&plusmn;", 177.ToChar()},
            {@"&plussim;", 10790.ToChar()},
            {@"&plustwo;", 10791.ToChar()},
            {@"&pm;", 177.ToChar()},
            {@"&Poincareplane;", 8460.ToChar()},
            {@"&pointint;", 10773.ToChar()},
            {@"&Popf;", 8473.ToChar()},
//{ @"&popf;", 120161.ToChar() },
            {@"&pound;", 163.ToChar()},
            {@"&Pr;", 10939.ToChar()},
            {@"&pr;", 8826.ToChar()},
            {@"&prap;", 10935.ToChar()},
            {@"&prcue;", 8828.ToChar()},
            {@"&prE;", 10931.ToChar()},
            {@"&pre;", 10927.ToChar()},
            {@"&prec;", 8826.ToChar()},
            {@"&precapprox;", 10935.ToChar()},
            {@"&preccurlyeq;", 8828.ToChar()},
            {@"&Precedes;", 8826.ToChar()},
            {@"&PrecedesEqual;", 10927.ToChar()},
            {@"&PrecedesSlantEqual;", 8828.ToChar()},
            {@"&PrecedesTilde;", 8830.ToChar()},
            {@"&preceq;", 10927.ToChar()},
            {@"&precnapprox;", 10937.ToChar()},
            {@"&precneqq;", 10933.ToChar()},
            {@"&precnsim;", 8936.ToChar()},
            {@"&precsim;", 8830.ToChar()},
            {@"&Prime;", 8243.ToChar()},
            {@"&prime;", 8242.ToChar()},
            {@"&primes;", 8473.ToChar()},
            {@"&prnap;", 10937.ToChar()},
            {@"&prnE;", 10933.ToChar()},
            {@"&prnsim;", 8936.ToChar()},
            {@"&prod;", 8719.ToChar()},
            {@"&Product;", 8719.ToChar()},
            {@"&profalar;", 9006.ToChar()},
            {@"&profline;", 8978.ToChar()},
            {@"&profsurf;", 8979.ToChar()},
            {@"&prop;", 8733.ToChar()},
            {@"&Proportion;", 8759.ToChar()},
            {@"&Proportional;", 8733.ToChar()},
            {@"&propto;", 8733.ToChar()},
            {@"&prsim;", 8830.ToChar()},
            {@"&prurel;", 8880.ToChar()},
//{ @"&Pscr;", 119979.ToChar() },
//{ @"&pscr;", 120005.ToChar() },
            {@"&Psi;", 936.ToChar()},
            {@"&psi;", 968.ToChar()},
            {@"&puncsp;", 8200.ToChar()},
//{ @"&Qfr;", 120084.ToChar() },
//{ @"&qfr;", 120110.ToChar() },
            {@"&qint;", 10764.ToChar()},
            {@"&Qopf;", 8474.ToChar()},
//{ @"&qopf;", 120162.ToChar() },
            {@"&qprime;", 8279.ToChar()},
//{ @"&Qscr;", 119980.ToChar() },
//{ @"&qscr;", 120006.ToChar() },
            {@"&quaternions;", 8461.ToChar()},
            {@"&quatint;", 10774.ToChar()},
            {@"&quest;", 63.ToChar()},
            {@"&questeq;", 8799.ToChar()},
            {@"&QUOT;", 34.ToChar()},
            {@"&quot;", 34.ToChar()},
            {@"&rAarr;", 8667.ToChar()},
            {@"&race;", 8765.ToChar()},
            {@"&Racute;", 340.ToChar()},
            {@"&racute;", 341.ToChar()},
            {@"&radic;", 8730.ToChar()},
            {@"&raemptyv;", 10675.ToChar()},
            {@"&Rang;", 10219.ToChar()},
            {@"&rang;", 10217.ToChar()},
            {@"&rangd;", 10642.ToChar()},
            {@"&range;", 10661.ToChar()},
            {@"&rangle;", 10217.ToChar()},
            {@"&raquo;", 187.ToChar()},
            {@"&Rarr;", 8608.ToChar()},
            {@"&rArr;", 8658.ToChar()},
            {@"&rarr;", 8594.ToChar()},
            {@"&rarrap;", 10613.ToChar()},
            {@"&rarrb;", 8677.ToChar()},
            {@"&rarrbfs;", 10528.ToChar()},
            {@"&rarrc;", 10547.ToChar()},
            {@"&rarrfs;", 10526.ToChar()},
            {@"&rarrhk;", 8618.ToChar()},
            {@"&rarrlp;", 8620.ToChar()},
            {@"&rarrpl;", 10565.ToChar()},
            {@"&rarrsim;", 10612.ToChar()},
            {@"&Rarrtl;", 10518.ToChar()},
            {@"&rarrtl;", 8611.ToChar()},
            {@"&rarrw;", 8605.ToChar()},
            {@"&rAtail;", 10524.ToChar()},
            {@"&ratail;", 10522.ToChar()},
            {@"&ratio;", 8758.ToChar()},
            {@"&rationals;", 8474.ToChar()},
            {@"&RBarr;", 10512.ToChar()},
            {@"&rBarr;", 10511.ToChar()},
            {@"&rbarr;", 10509.ToChar()},
            {@"&rbbrk;", 10099.ToChar()},
            {@"&rbrace;", 125.ToChar()},
            {@"&rbrack;", 93.ToChar()},
            {@"&rbrke;", 10636.ToChar()},
            {@"&rbrksld;", 10638.ToChar()},
            {@"&rbrkslu;", 10640.ToChar()},
            {@"&Rcaron;", 344.ToChar()},
            {@"&rcaron;", 345.ToChar()},
            {@"&Rcedil;", 342.ToChar()},
            {@"&rcedil;", 343.ToChar()},
            {@"&rceil;", 8969.ToChar()},
            {@"&rcub;", 125.ToChar()},
            {@"&Rcy;", 1056.ToChar()},
            {@"&rcy;", 1088.ToChar()},
            {@"&rdca;", 10551.ToChar()},
            {@"&rdldhar;", 10601.ToChar()},
            {@"&rdquo;", 8221.ToChar()},
            {@"&rdquor;", 8221.ToChar()},
            {@"&rdsh;", 8627.ToChar()},
            {@"&Re;", 8476.ToChar()},
            {@"&real;", 8476.ToChar()},
            {@"&realine;", 8475.ToChar()},
            {@"&realpart;", 8476.ToChar()},
            {@"&reals;", 8477.ToChar()},
            {@"&rect;", 9645.ToChar()},
            {@"&REG;", 174.ToChar()},
            {@"&reg;", 174.ToChar()},
            {@"&ReverseElement;", 8715.ToChar()},
            {@"&ReverseEquilibrium;", 8651.ToChar()},
            {@"&ReverseUpEquilibrium;", 10607.ToChar()},
            {@"&rfisht;", 10621.ToChar()},
            {@"&rfloor;", 8971.ToChar()},
            {@"&Rfr;", 8476.ToChar()},
//{ @"&rfr;", 120111.ToChar() },
            {@"&rHar;", 10596.ToChar()},
            {@"&rhard;", 8641.ToChar()},
            {@"&rharu;", 8640.ToChar()},
            {@"&rharul;", 10604.ToChar()},
            {@"&Rho;", 929.ToChar()},
            {@"&rho;", 961.ToChar()},
            {@"&rhov;", 1009.ToChar()},
            {@"&RightAngleBracket;", 10217.ToChar()},
            {@"&RightArrow;", 8594.ToChar()},
            {@"&Rightarrow;", 8658.ToChar()},
            {@"&rightarrow;", 8594.ToChar()},
            {@"&RightArrowBar;", 8677.ToChar()},
            {@"&RightArrowLeftArrow;", 8644.ToChar()},
            {@"&rightarrowtail;", 8611.ToChar()},
            {@"&RightCeiling;", 8969.ToChar()},
            {@"&RightDoubleBracket;", 10215.ToChar()},
            {@"&RightDownTeeVector;", 10589.ToChar()},
            {@"&RightDownVector;", 8642.ToChar()},
            {@"&RightDownVectorBar;", 10581.ToChar()},
            {@"&RightFloor;", 8971.ToChar()},
            {@"&rightharpoondown;", 8641.ToChar()},
            {@"&rightharpoonup;", 8640.ToChar()},
            {@"&rightleftarrows;", 8644.ToChar()},
            {@"&rightleftharpoons;", 8652.ToChar()},
            {@"&rightrightarrows;", 8649.ToChar()},
            {@"&rightsquigarrow;", 8605.ToChar()},
            {@"&RightTee;", 8866.ToChar()},
            {@"&RightTeeArrow;", 8614.ToChar()},
            {@"&RightTeeVector;", 10587.ToChar()},
            {@"&rightthreetimes;", 8908.ToChar()},
            {@"&RightTriangle;", 8883.ToChar()},
            {@"&RightTriangleBar;", 10704.ToChar()},
            {@"&RightTriangleEqual;", 8885.ToChar()},
            {@"&RightUpDownVector;", 10575.ToChar()},
            {@"&RightUpTeeVector;", 10588.ToChar()},
            {@"&RightUpVector;", 8638.ToChar()},
            {@"&RightUpVectorBar;", 10580.ToChar()},
            {@"&RightVector;", 8640.ToChar()},
            {@"&RightVectorBar;", 10579.ToChar()},
            {@"&ring;", 730.ToChar()},
            {@"&risingdotseq;", 8787.ToChar()},
            {@"&rlarr;", 8644.ToChar()},
            {@"&rlhar;", 8652.ToChar()},
            {@"&rlm;", 8207.ToChar()},
            {@"&rmoust;", 9137.ToChar()},
            {@"&rmoustache;", 9137.ToChar()},
            {@"&rnmid;", 10990.ToChar()},
            {@"&roang;", 10221.ToChar()},
            {@"&roarr;", 8702.ToChar()},
            {@"&robrk;", 10215.ToChar()},
            {@"&ropar;", 10630.ToChar()},
            {@"&Ropf;", 8477.ToChar()},
//{ @"&ropf;", 120163.ToChar() },
            {@"&roplus;", 10798.ToChar()},
            {@"&rotimes;", 10805.ToChar()},
            {@"&RoundImplies;", 10608.ToChar()},
            {@"&rpar;", 41.ToChar()},
            {@"&rpargt;", 10644.ToChar()},
            {@"&rppolint;", 10770.ToChar()},
            {@"&rrarr;", 8649.ToChar()},
            {@"&Rrightarrow;", 8667.ToChar()},
            {@"&rsaquo;", 8250.ToChar()},
            {@"&Rscr;", 8475.ToChar()},
//{ @"&rscr;", 120007.ToChar() },
            {@"&Rsh;", 8625.ToChar()},
            {@"&rsh;", 8625.ToChar()},
            {@"&rsqb;", 93.ToChar()},
            {@"&rsquo;", 8217.ToChar()},
            {@"&rsquor;", 8217.ToChar()},
            {@"&rthree;", 8908.ToChar()},
            {@"&rtimes;", 8906.ToChar()},
            {@"&rtri;", 9657.ToChar()},
            {@"&rtrie;", 8885.ToChar()},
            {@"&rtrif;", 9656.ToChar()},
            {@"&rtriltri;", 10702.ToChar()},
            {@"&RuleDelayed;", 10740.ToChar()},
            {@"&ruluhar;", 10600.ToChar()},
            {@"&rx;", 8478.ToChar()},
            {@"&Sacute;", 346.ToChar()},
            {@"&sacute;", 347.ToChar()},
            {@"&sbquo;", 8218.ToChar()},
            {@"&Sc;", 10940.ToChar()},
            {@"&sc;", 8827.ToChar()},
            {@"&scap;", 10936.ToChar()},
            {@"&Scaron;", 352.ToChar()},
            {@"&scaron;", 353.ToChar()},
            {@"&sccue;", 8829.ToChar()},
            {@"&scE;", 10932.ToChar()},
            {@"&sce;", 10928.ToChar()},
            {@"&Scedil;", 350.ToChar()},
            {@"&scedil;", 351.ToChar()},
            {@"&Scirc;", 348.ToChar()},
            {@"&scirc;", 349.ToChar()},
            {@"&scnap;", 10938.ToChar()},
            {@"&scnE;", 10934.ToChar()},
            {@"&scnsim;", 8937.ToChar()},
            {@"&scpolint;", 10771.ToChar()},
            {@"&scsim;", 8831.ToChar()},
            {@"&Scy;", 1057.ToChar()},
            {@"&scy;", 1089.ToChar()},
            {@"&sdot;", 8901.ToChar()},
            {@"&sdotb;", 8865.ToChar()},
            {@"&sdote;", 10854.ToChar()},
            {@"&searhk;", 10533.ToChar()},
            {@"&seArr;", 8664.ToChar()},
            {@"&searr;", 8600.ToChar()},
            {@"&searrow;", 8600.ToChar()},
            {@"&sect;", 167.ToChar()},
            {@"&semi;", 59.ToChar()},
            {@"&seswar;", 10537.ToChar()},
            {@"&setminus;", 8726.ToChar()},
            {@"&setmn;", 8726.ToChar()},
            {@"&sext;", 10038.ToChar()},
//{ @"&Sfr;", 120086.ToChar() },
//{ @"&sfr;", 120112.ToChar() },
            {@"&sfrown;", 8994.ToChar()},
            {@"&sharp;", 9839.ToChar()},
            {@"&SHCHcy;", 1065.ToChar()},
            {@"&shchcy;", 1097.ToChar()},
            {@"&SHcy;", 1064.ToChar()},
            {@"&shcy;", 1096.ToChar()},
            {@"&ShortDownArrow;", 8595.ToChar()},
            {@"&ShortLeftArrow;", 8592.ToChar()},
            {@"&shortmid;", 8739.ToChar()},
            {@"&shortparallel;", 8741.ToChar()},
            {@"&ShortRightArrow;", 8594.ToChar()},
            {@"&ShortUpArrow;", 8593.ToChar()},
            {@"&shy;", 173.ToChar()},
            {@"&Sigma;", 931.ToChar()},
            {@"&sigma;", 963.ToChar()},
            {@"&sigmaf;", 962.ToChar()},
            {@"&sigmav;", 962.ToChar()},
            {@"&sim;", 8764.ToChar()},
            {@"&simdot;", 10858.ToChar()},
            {@"&sime;", 8771.ToChar()},
            {@"&simeq;", 8771.ToChar()},
            {@"&simg;", 10910.ToChar()},
            {@"&simgE;", 10912.ToChar()},
            {@"&siml;", 10909.ToChar()},
            {@"&simlE;", 10911.ToChar()},
            {@"&simne;", 8774.ToChar()},
            {@"&simplus;", 10788.ToChar()},
            {@"&simrarr;", 10610.ToChar()},
            {@"&slarr;", 8592.ToChar()},
            {@"&SmallCircle;", 8728.ToChar()},
            {@"&smallsetminus;", 8726.ToChar()},
            {@"&smashp;", 10803.ToChar()},
            {@"&smeparsl;", 10724.ToChar()},
            {@"&smid;", 8739.ToChar()},
            {@"&smile;", 8995.ToChar()},
            {@"&smt;", 10922.ToChar()},
            {@"&smte;", 10924.ToChar()},
            {@"&smtes;", 10924.ToChar()},
            {@"&SOFTcy;", 1068.ToChar()},
            {@"&softcy;", 1100.ToChar()},
            {@"&sol;", 47.ToChar()},
            {@"&solb;", 10692.ToChar()},
            {@"&solbar;", 9023.ToChar()},
//{ @"&Sopf;", 120138.ToChar() },
//{ @"&sopf;", 120164.ToChar() },
            {@"&spades;", 9824.ToChar()},
            {@"&spadesuit;", 9824.ToChar()},
            {@"&spar;", 8741.ToChar()},
            {@"&sqcap;", 8851.ToChar()},
            {@"&sqcaps;", 8851.ToChar()},
            {@"&sqcup;", 8852.ToChar()},
            {@"&sqcups;", 8852.ToChar()},
            {@"&Sqrt;", 8730.ToChar()},
            {@"&sqsub;", 8847.ToChar()},
            {@"&sqsube;", 8849.ToChar()},
            {@"&sqsubset;", 8847.ToChar()},
            {@"&sqsubseteq;", 8849.ToChar()},
            {@"&sqsup;", 8848.ToChar()},
            {@"&sqsupe;", 8850.ToChar()},
            {@"&sqsupset;", 8848.ToChar()},
            {@"&sqsupseteq;", 8850.ToChar()},
            {@"&squ;", 9633.ToChar()},
            {@"&Square;", 9633.ToChar()},
            {@"&square;", 9633.ToChar()},
            {@"&SquareIntersection;", 8851.ToChar()},
            {@"&SquareSubset;", 8847.ToChar()},
            {@"&SquareSubsetEqual;", 8849.ToChar()},
            {@"&SquareSuperset;", 8848.ToChar()},
            {@"&SquareSupersetEqual;", 8850.ToChar()},
            {@"&SquareUnion;", 8852.ToChar()},
            {@"&squarf;", 9642.ToChar()},
            {@"&squf;", 9642.ToChar()},
            {@"&srarr;", 8594.ToChar()},
//{ @"&Sscr;", 119982.ToChar() },
//{ @"&sscr;", 120008.ToChar() },
            {@"&ssetmn;", 8726.ToChar()},
            {@"&ssmile;", 8995.ToChar()},
            {@"&sstarf;", 8902.ToChar()},
            {@"&Star;", 8902.ToChar()},
            {@"&star;", 9734.ToChar()},
            {@"&starf;", 9733.ToChar()},
            {@"&straightepsilon;", 1013.ToChar()},
            {@"&straightphi;", 981.ToChar()},
            {@"&strns;", 175.ToChar()},
            {@"&Sub;", 8912.ToChar()},
            {@"&sub;", 8834.ToChar()},
            {@"&subdot;", 10941.ToChar()},
            {@"&subE;", 10949.ToChar()},
            {@"&sube;", 8838.ToChar()},
            {@"&subedot;", 10947.ToChar()},
            {@"&submult;", 10945.ToChar()},
            {@"&subnE;", 10955.ToChar()},
            {@"&subne;", 8842.ToChar()},
            {@"&subplus;", 10943.ToChar()},
            {@"&subrarr;", 10617.ToChar()},
            {@"&Subset;", 8912.ToChar()},
            {@"&subset;", 8834.ToChar()},
            {@"&subseteq;", 8838.ToChar()},
            {@"&subseteqq;", 10949.ToChar()},
            {@"&SubsetEqual;", 8838.ToChar()},
            {@"&subsetneq;", 8842.ToChar()},
            {@"&subsetneqq;", 10955.ToChar()},
            {@"&subsim;", 10951.ToChar()},
            {@"&subsub;", 10965.ToChar()},
            {@"&subsup;", 10963.ToChar()},
            {@"&succ;", 8827.ToChar()},
            {@"&succapprox;", 10936.ToChar()},
            {@"&succcurlyeq;", 8829.ToChar()},
            {@"&Succeeds;", 8827.ToChar()},
            {@"&SucceedsEqual;", 10928.ToChar()},
            {@"&SucceedsSlantEqual;", 8829.ToChar()},
            {@"&SucceedsTilde;", 8831.ToChar()},
            {@"&succeq;", 10928.ToChar()},
            {@"&succnapprox;", 10938.ToChar()},
            {@"&succneqq;", 10934.ToChar()},
            {@"&succnsim;", 8937.ToChar()},
            {@"&succsim;", 8831.ToChar()},
            {@"&SuchThat;", 8715.ToChar()},
            {@"&Sum;", 8721.ToChar()},
            {@"&sum;", 8721.ToChar()},
            {@"&sung;", 9834.ToChar()},
            {@"&Sup;", 8913.ToChar()},
            {@"&sup;", 8835.ToChar()},
            {@"&sup1;", 185.ToChar()},
            {@"&sup2;", 178.ToChar()},
            {@"&sup3;", 179.ToChar()},
            {@"&supdot;", 10942.ToChar()},
            {@"&supdsub;", 10968.ToChar()},
            {@"&supE;", 10950.ToChar()},
            {@"&supe;", 8839.ToChar()},
            {@"&supedot;", 10948.ToChar()},
            {@"&Superset;", 8835.ToChar()},
            {@"&SupersetEqual;", 8839.ToChar()},
            {@"&suphsol;", 10185.ToChar()},
            {@"&suphsub;", 10967.ToChar()},
            {@"&suplarr;", 10619.ToChar()},
            {@"&supmult;", 10946.ToChar()},
            {@"&supnE;", 10956.ToChar()},
            {@"&supne;", 8843.ToChar()},
            {@"&supplus;", 10944.ToChar()},
            {@"&Supset;", 8913.ToChar()},
            {@"&supset;", 8835.ToChar()},
            {@"&supseteq;", 8839.ToChar()},
            {@"&supseteqq;", 10950.ToChar()},
            {@"&supsetneq;", 8843.ToChar()},
            {@"&supsetneqq;", 10956.ToChar()},
            {@"&supsim;", 10952.ToChar()},
            {@"&supsub;", 10964.ToChar()},
            {@"&supsup;", 10966.ToChar()},
            {@"&swarhk;", 10534.ToChar()},
            {@"&swArr;", 8665.ToChar()},
            {@"&swarr;", 8601.ToChar()},
            {@"&swarrow;", 8601.ToChar()},
            {@"&swnwar;", 10538.ToChar()},
            {@"&szlig;", 223.ToChar()},
            {@"&Tab;", 9.ToChar()},
            {@"&target;", 8982.ToChar()},
            {@"&Tau;", 932.ToChar()},
            {@"&tau;", 964.ToChar()},
            {@"&tbrk;", 9140.ToChar()},
            {@"&Tcaron;", 356.ToChar()},
            {@"&tcaron;", 357.ToChar()},
            {@"&Tcedil;", 354.ToChar()},
            {@"&tcedil;", 355.ToChar()},
            {@"&Tcy;", 1058.ToChar()},
            {@"&tcy;", 1090.ToChar()},
            {@"&tdot;", 8411.ToChar()},
            {@"&telrec;", 8981.ToChar()},
//{ @"&Tfr;", 120087.ToChar() },
//{ @"&tfr;", 120113.ToChar() },
            {@"&there4;", 8756.ToChar()},
            {@"&Therefore;", 8756.ToChar()},
            {@"&therefore;", 8756.ToChar()},
            {@"&Theta;", 920.ToChar()},
            {@"&theta;", 952.ToChar()},
            {@"&thetasym;", 977.ToChar()},
            {@"&thetav;", 977.ToChar()},
            {@"&thickapprox;", 8776.ToChar()},
            {@"&thicksim;", 8764.ToChar()},
            {@"&ThickSpace;", 8287.ToChar()},
            {@"&thinsp;", 8201.ToChar()},
            {@"&ThinSpace;", 8201.ToChar()},
            {@"&thkap;", 8776.ToChar()},
            {@"&thksim;", 8764.ToChar()},
            {@"&THORN;", 222.ToChar()},
            {@"&thorn;", 254.ToChar()},
            {@"&Tilde;", 8764.ToChar()},
            {@"&tilde;", 732.ToChar()},
            {@"&TildeEqual;", 8771.ToChar()},
            {@"&TildeFullEqual;", 8773.ToChar()},
            {@"&TildeTilde;", 8776.ToChar()},
            {@"&times;", 215.ToChar()},
            {@"&timesb;", 8864.ToChar()},
            {@"&timesbar;", 10801.ToChar()},
            {@"&timesd;", 10800.ToChar()},
            {@"&tint;", 8749.ToChar()},
            {@"&toea;", 10536.ToChar()},
            {@"&top;", 8868.ToChar()},
            {@"&topbot;", 9014.ToChar()},
            {@"&topcir;", 10993.ToChar()},
//{ @"&Topf;", 120139.ToChar() },
//{ @"&topf;", 120165.ToChar() },
            {@"&topfork;", 10970.ToChar()},
            {@"&tosa;", 10537.ToChar()},
            {@"&tprime;", 8244.ToChar()},
            {@"&TRADE;", 8482.ToChar()},
            {@"&trade;", 8482.ToChar()},
            {@"&triangle;", 9653.ToChar()},
            {@"&triangledown;", 9663.ToChar()},
            {@"&triangleleft;", 9667.ToChar()},
            {@"&trianglelefteq;", 8884.ToChar()},
            {@"&triangleq;", 8796.ToChar()},
            {@"&triangleright;", 9657.ToChar()},
            {@"&trianglerighteq;", 8885.ToChar()},
            {@"&tridot;", 9708.ToChar()},
            {@"&trie;", 8796.ToChar()},
            {@"&triminus;", 10810.ToChar()},
            {@"&TripleDot;", 8411.ToChar()},
            {@"&triplus;", 10809.ToChar()},
            {@"&trisb;", 10701.ToChar()},
            {@"&tritime;", 10811.ToChar()},
            {@"&trpezium;", 9186.ToChar()},
//{ @"&Tscr;", 119983.ToChar() },
//{ @"&tscr;", 120009.ToChar() },
            {@"&TScy;", 1062.ToChar()},
            {@"&tscy;", 1094.ToChar()},
            {@"&TSHcy;", 1035.ToChar()},
            {@"&tshcy;", 1115.ToChar()},
            {@"&Tstrok;", 358.ToChar()},
            {@"&tstrok;", 359.ToChar()},
            {@"&twixt;", 8812.ToChar()},
            {@"&twoheadleftarrow;", 8606.ToChar()},
            {@"&twoheadrightarrow;", 8608.ToChar()},
            {@"&Uacute;", 218.ToChar()},
            {@"&uacute;", 250.ToChar()},
            {@"&Uarr;", 8607.ToChar()},
            {@"&uArr;", 8657.ToChar()},
            {@"&uarr;", 8593.ToChar()},
            {@"&Uarrocir;", 10569.ToChar()},
            {@"&Ubrcy;", 1038.ToChar()},
            {@"&ubrcy;", 1118.ToChar()},
            {@"&Ubreve;", 364.ToChar()},
            {@"&ubreve;", 365.ToChar()},
            {@"&Ucirc;", 219.ToChar()},
            {@"&ucirc;", 251.ToChar()},
            {@"&Ucy;", 1059.ToChar()},
            {@"&ucy;", 1091.ToChar()},
            {@"&udarr;", 8645.ToChar()},
            {@"&Udblac;", 368.ToChar()},
            {@"&udblac;", 369.ToChar()},
            {@"&udhar;", 10606.ToChar()},
            {@"&ufisht;", 10622.ToChar()},
//{ @"&Ufr;", 120088.ToChar() },
//{ @"&ufr;", 120114.ToChar() },
            {@"&Ugrave;", 217.ToChar()},
            {@"&ugrave;", 249.ToChar()},
            {@"&uHar;", 10595.ToChar()},
            {@"&uharl;", 8639.ToChar()},
            {@"&uharr;", 8638.ToChar()},
            {@"&uhblk;", 9600.ToChar()},
            {@"&ulcorn;", 8988.ToChar()},
            {@"&ulcorner;", 8988.ToChar()},
            {@"&ulcrop;", 8975.ToChar()},
            {@"&ultri;", 9720.ToChar()},
            {@"&Umacr;", 362.ToChar()},
            {@"&umacr;", 363.ToChar()},
            {@"&uml;", 168.ToChar()},
            {@"&UnderBar;", 95.ToChar()},
            {@"&UnderBrace;", 9183.ToChar()},
            {@"&UnderBracket;", 9141.ToChar()},
            {@"&UnderParenthesis;", 9181.ToChar()},
            {@"&Union;", 8899.ToChar()},
            {@"&UnionPlus;", 8846.ToChar()},
            {@"&Uogon;", 370.ToChar()},
            {@"&uogon;", 371.ToChar()},
//{ @"&Uopf;", 120140.ToChar() },
//{ @"&uopf;", 120166.ToChar() },
            {@"&UpArrow;", 8593.ToChar()},
            {@"&Uparrow;", 8657.ToChar()},
            {@"&uparrow;", 8593.ToChar()},
            {@"&UpArrowBar;", 10514.ToChar()},
            {@"&UpArrowDownArrow;", 8645.ToChar()},
            {@"&UpDownArrow;", 8597.ToChar()},
            {@"&Updownarrow;", 8661.ToChar()},
            {@"&updownarrow;", 8597.ToChar()},
            {@"&UpEquilibrium;", 10606.ToChar()},
            {@"&upharpoonleft;", 8639.ToChar()},
            {@"&upharpoonright;", 8638.ToChar()},
            {@"&uplus;", 8846.ToChar()},
            {@"&UpperLeftArrow;", 8598.ToChar()},
            {@"&UpperRightArrow;", 8599.ToChar()},
            {@"&Upsi;", 978.ToChar()},
            {@"&upsi;", 965.ToChar()},
            {@"&upsih;", 978.ToChar()},
            {@"&Upsilon;", 933.ToChar()},
            {@"&upsilon;", 965.ToChar()},
            {@"&UpTee;", 8869.ToChar()},
            {@"&UpTeeArrow;", 8613.ToChar()},
            {@"&upuparrows;", 8648.ToChar()},
            {@"&urcorn;", 8989.ToChar()},
            {@"&urcorner;", 8989.ToChar()},
            {@"&urcrop;", 8974.ToChar()},
            {@"&Uring;", 366.ToChar()},
            {@"&uring;", 367.ToChar()},
            {@"&urtri;", 9721.ToChar()},
//{ @"&Uscr;", 119984.ToChar() },
//{ @"&uscr;", 120010.ToChar() },
            {@"&utdot;", 8944.ToChar()},
            {@"&Utilde;", 360.ToChar()},
            {@"&utilde;", 361.ToChar()},
            {@"&utri;", 9653.ToChar()},
            {@"&utrif;", 9652.ToChar()},
            {@"&uuarr;", 8648.ToChar()},
            {@"&Uuml;", 220.ToChar()},
            {@"&uuml;", 252.ToChar()},
            {@"&uwangle;", 10663.ToChar()},
            {@"&vangrt;", 10652.ToChar()},
            {@"&varepsilon;", 1013.ToChar()},
            {@"&varkappa;", 1008.ToChar()},
            {@"&varnothing;", 8709.ToChar()},
            {@"&varphi;", 981.ToChar()},
            {@"&varpi;", 982.ToChar()},
            {@"&varpropto;", 8733.ToChar()},
            {@"&vArr;", 8661.ToChar()},
            {@"&varr;", 8597.ToChar()},
            {@"&varrho;", 1009.ToChar()},
            {@"&varsigma;", 962.ToChar()},
            {@"&varsubsetneq;", 8842.ToChar()},
            {@"&varsubsetneqq;", 10955.ToChar()},
            {@"&varsupsetneq;", 8843.ToChar()},
            {@"&varsupsetneqq;", 10956.ToChar()},
            {@"&vartheta;", 977.ToChar()},
            {@"&vartriangleleft;", 8882.ToChar()},
            {@"&vartriangleright;", 8883.ToChar()},
            {@"&Vbar;", 10987.ToChar()},
            {@"&vBar;", 10984.ToChar()},
            {@"&vBarv;", 10985.ToChar()},
            {@"&Vcy;", 1042.ToChar()},
            {@"&vcy;", 1074.ToChar()},
            {@"&VDash;", 8875.ToChar()},
            {@"&Vdash;", 8873.ToChar()},
            {@"&vDash;", 8872.ToChar()},
            {@"&vdash;", 8866.ToChar()},
            {@"&Vdashl;", 10982.ToChar()},
            {@"&Vee;", 8897.ToChar()},
            {@"&vee;", 8744.ToChar()},
            {@"&veebar;", 8891.ToChar()},
            {@"&veeeq;", 8794.ToChar()},
            {@"&vellip;", 8942.ToChar()},
            {@"&Verbar;", 8214.ToChar()},
            {@"&verbar;", 124.ToChar()},
            {@"&Vert;", 8214.ToChar()},
            {@"&vert;", 124.ToChar()},
            {@"&VerticalBar;", 8739.ToChar()},
            {@"&VerticalLine;", 124.ToChar()},
            {@"&VerticalSeparator;", 10072.ToChar()},
            {@"&VerticalTilde;", 8768.ToChar()},
            {@"&VeryThinSpace;", 8202.ToChar()},
//{ @"&Vfr;", 120089.ToChar() },
//{ @"&vfr;", 120115.ToChar() },
            {@"&vltri;", 8882.ToChar()},
            {@"&vnsub;", 8834.ToChar()},
            {@"&vnsup;", 8835.ToChar()},
//{ @"&Vopf;", 120141.ToChar() },
//{ @"&vopf;", 120167.ToChar() },
            {@"&vprop;", 8733.ToChar()},
            {@"&vrtri;", 8883.ToChar()},
//{ @"&Vscr;", 119985.ToChar() },
//{ @"&vscr;", 120011.ToChar() },
            {@"&vsubnE;", 10955.ToChar()},
            {@"&vsubne;", 8842.ToChar()},
            {@"&vsupnE;", 10956.ToChar()},
            {@"&vsupne;", 8843.ToChar()},
            {@"&Vvdash;", 8874.ToChar()},
            {@"&vzigzag;", 10650.ToChar()},
            {@"&Wcirc;", 372.ToChar()},
            {@"&wcirc;", 373.ToChar()},
            {@"&wedbar;", 10847.ToChar()},
            {@"&Wedge;", 8896.ToChar()},
            {@"&wedge;", 8743.ToChar()},
            {@"&wedgeq;", 8793.ToChar()},
            {@"&weierp;", 8472.ToChar()},
//{ @"&Wfr;", 120090.ToChar() },
//{ @"&wfr;", 120116.ToChar() },
//{ @"&Wopf;", 120142.ToChar() },
//{ @"&wopf;", 120168.ToChar() },
            {@"&wp;", 8472.ToChar()},
            {@"&wr;", 8768.ToChar()},
            {@"&wreath;", 8768.ToChar()},
//{ @"&Wscr;", 119986.ToChar() },
//{ @"&wscr;", 120012.ToChar() },
            {@"&xcap;", 8898.ToChar()},
            {@"&xcirc;", 9711.ToChar()},
            {@"&xcup;", 8899.ToChar()},
            {@"&xdtri;", 9661.ToChar()},
//{ @"&Xfr;", 120091.ToChar() },
//{ @"&xfr;", 120117.ToChar() },
            {@"&xhArr;", 10234.ToChar()},
            {@"&xharr;", 10231.ToChar()},
            {@"&Xi;", 926.ToChar()},
            {@"&xi;", 958.ToChar()},
            {@"&xlArr;", 10232.ToChar()},
            {@"&xlarr;", 10229.ToChar()},
            {@"&xmap;", 10236.ToChar()},
            {@"&xnis;", 8955.ToChar()},
            {@"&xodot;", 10752.ToChar()},
//{ @"&Xopf;", 120143.ToChar() },
//{ @"&xopf;", 120169.ToChar() },
            {@"&xoplus;", 10753.ToChar()},
            {@"&xotime;", 10754.ToChar()},
            {@"&xrArr;", 10233.ToChar()},
            {@"&xrarr;", 10230.ToChar()},
//{ @"&Xscr;", 119987.ToChar() },
//{ @"&xscr;", 120013.ToChar() },
            {@"&xsqcup;", 10758.ToChar()},
            {@"&xuplus;", 10756.ToChar()},
            {@"&xutri;", 9651.ToChar()},
            {@"&xvee;", 8897.ToChar()},
            {@"&xwedge;", 8896.ToChar()},
            {@"&Yacute;", 221.ToChar()},
            {@"&yacute;", 253.ToChar()},
            {@"&YAcy;", 1071.ToChar()},
            {@"&yacy;", 1103.ToChar()},
            {@"&Ycirc;", 374.ToChar()},
            {@"&ycirc;", 375.ToChar()},
            {@"&Ycy;", 1067.ToChar()},
            {@"&ycy;", 1099.ToChar()},
            {@"&yen;", 165.ToChar()},
//{ @"&Yfr;", 120092.ToChar() },
//{ @"&yfr;", 120118.ToChar() },
            {@"&YIcy;", 1031.ToChar()},
            {@"&yicy;", 1111.ToChar()},
//{ @"&Yopf;", 120144.ToChar() },
//{ @"&yopf;", 120170.ToChar() },
//{ @"&Yscr;", 119988.ToChar() },
//{ @"&yscr;", 120014.ToChar() },
            {@"&YUcy;", 1070.ToChar()},
            {@"&yucy;", 1102.ToChar()},
            {@"&Yuml;", 376.ToChar()},
            {@"&yuml;", 255.ToChar()},
            {@"&Zacute;", 377.ToChar()},
            {@"&zacute;", 378.ToChar()},
            {@"&Zcaron;", 381.ToChar()},
            {@"&zcaron;", 382.ToChar()},
            {@"&Zcy;", 1047.ToChar()},
            {@"&zcy;", 1079.ToChar()},
            {@"&Zdot;", 379.ToChar()},
            {@"&zdot;", 380.ToChar()},
            {@"&zeetrf;", 8488.ToChar()},
            {@"&ZeroWidthSpace;", 8203.ToChar()},
            {@"&Zeta;", 918.ToChar()},
            {@"&zeta;", 950.ToChar()},
            {@"&Zfr;", 8488.ToChar()},
//{ @"&zfr;", 120119.ToChar() },
            {@"&ZHcy;", 1046.ToChar()},
            {@"&zhcy;", 1078.ToChar()},
            {@"&zigrarr;", 8669.ToChar()},
            {@"&Zopf;", 8484.ToChar()},
//{ @"&zopf;", 120171.ToChar() },
//{ @"&Zscr;", 119989.ToChar() },
//{ @"&zscr;", 120015.ToChar() },
            {@"&zwj;", 8205.ToChar()},
            {@"&zwnj;", 8204.ToChar()},
        };
    }
}